Una introducción a la programación en Emacs Lisp

Esto es una Introducción a la Programación en Emacs Lisp, para personas que no son programadoras.

Traducido desde la edición 3.10

Copyright ® 1990–1995, 1997, 2001–2013 Free Software Foundation, Inc.

Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; there being no Invariant Section, with the Front-Cover Texts being “A GNU Manual”, and with the Back-Cover Texts as in (a) below. A copy of the license is included in the section entitled “GNU Free Documentation License”.

(a) The FSF's Back-Cover Text is: “You have the freedom to copy and modify this GNU manual. Buying copies from the FSF supports it in developing GNU and promoting software freedom.”

La mayoría del entorno integrado GNU Emacs está escrito en el lenguaje de programación llamado Emacs Lisp. El código escrito en este lenguaje de programación es el software––el conjunto de instrucciones––que le indican al ordenador qué hacer cuando se le dan comandos. Emacs está diseñado de forma que se pueda escribir nuevo código en Emacs Lisp e instalarlo fácilmente como una extensión al editor.

(GNU Emacs se define muchas veces como un “editor extensible”, pero hace mucho más que proporcionar capacidad de edición. Es mejor referirse a Emacs como un “entorno de computación extensible”. Sin embargo, esa frase es un poco pretenciosa. Es más fácil referirse a Emacs simplemente como un editor. De hecho, cada cosa que se hace en Emacs––encontrar la fecha Maya y fases de la luna, simplificar polinomios, depurar código, administrar ficheros, leer cartas, escribir libros––todas estas actividades son maneras de editar en un sentido mas amplio de la palabra.)

Aunque Emacs Lisp normalmente se asocia solo con Emacs, es un lenguaje de programación completo. Se puede usar Emacs Lisp del mismo modo que con cualquier otro lenguaje de programación.

Quizás quieras entender la programación; quizás quieras extender Emacs; o tal vez quieras convertirte en un programador. Esta introducción a Emacs Lisp está diseñada para que empieces: para guiarte en el aprendizaje de los fundamentos de la programación y, lo que es más importante, para mostrarte como puedes aprender a ir mas más allá.

A lo largo de este documento, verás pequeños programas de ejemplo que se pueden ejecutar dentro de Emacs. Si lees este documento dentro de GNU Emacs, puedes ejecutar los programas tal y como aparecen. (Esto es fácil de hacer y se explica cuando se presentan los ejemplos). Alternativamente, puedes leer esta introducción como un libro impreso mientras se está sentando frente a un ordenador ejecutando Emacs. (Esto es lo que me gusta hacer; me gustan los libros impresos.) Si no tienes un Emacs funcionando a tu lado, todavía puedes leer este libro, pero en este caso, lo mejor es tratarlo como una novela, o como una guía de viaje a un país que aún no visitas: interesante, pero no es lo mismo que estar allí.

Gran parte de esta introducción esta dedicada a recorridos o visitas guiadas del código usado en GNU Emacs. Estos recorridos están diseñados para dos propósitos: primero, para que te familiarices con el código de trabajo real (código que se usa cada día); y, segundo, para que te familiarices con el funcionamiento de Emacs. Es interesante ver cómo se implementa un entorno de trabajo completamente operativo. Ademas, espero que adquieras el hábito de navegar a través del código fuente. Puedes aprender mucho comparando código de otros con el propio y extraer nuevas ideas. Tener GNU Emacs es como tener la cueva del dragón de los tesoros.

Además de aprender sobre Emacs como editor y Emacs Lisp como lenguaje de programación, los ejemplos y visitas guiadas te darán una oportunidad para familiarizarte con Emacs como entorno de programación Lisp. GNU Emacs soporta programación y provee herramientas que llegaras a sentirte comodo usando, como M-. (el atajo que invoca el comando find-tag). También aprenderas sobre los búfers y otros objetos que forman parte del entorno. Aprender estas caracteristicas de Emacs es como aprender nuevas rutas alrededor de tu ciudad natal.

Finalmente, espero poder transmitirte algunas habilidades para utilizar Emacs con el fin de aprender aspectos de programación que no conoces. Con frecuencia se puede usar Emacs como ayuda para entender un rompecabezas o para encontrar la manera de hacer algo nuevo. Este auto-descubrimiento no es solo un placer, también es una ventaja.

Este texto está escrito como una introducción elemental para personas que no son programadoras. Si eres es un programador, es posible que no estes satisfecho con este manual. La razón es que un programador puede tener que convertirse en experto leyendo manuales de referencia y este texto no está organizado como un manual de referencia.

Un programador experto que revisó este texto me dijo:

Prefiero aprender desde manuales de referencia. Me “zambullo” en cada párrafo y “subo a tomar aire” entre párrafos.

Cuando llego al fin de un párrafo, asumo que este asunto está hecho, terminado, que sé todo lo que necesito (con la posible excepción del caso en que el siguiente párrafo empiece a hablar de ello con más detalle). Espero que un manual de referencia bien escrito no tenga mucha redundancia, y que tenga excelentes indicadores del (unico) lugar donde está la información que quiero.

¡Esta introducción no está escrita para esta persona!

En primer lugar, intento decir cada cosa al menos tres veces: primero, para introducirlo; segundo, para mostrarlo en contexto; y tercero, para mostrarlo en un contexto diferente, o revisarlo.

En segundo lugar, casi nunca pongo toda la información sobre un tema en un solo lugar, y mucho menos en un párrafo. A mi manera de pensar, eso impone una carga bastante pesada al lector. En cambio, trato de explicar solo lo que necesitas saber en ese momento. (Algunas veces incluyo una pequeña información extra, para que no haya sorpresas más tarde cuando la información adicional sea presentada formalmente.)

Cuando leas este texto, no se esperes aprender todo la primera vez. Frecuentemente, solo necesitas, por asi decirlo, un ‘asentir con la cabeza’ en alguno de los articulos mencionados. Mi esperanza es haber estructurado el texto y dar suficientes pistas para indicar lo que es importante y te concentres en ello.

Necesitaras “sumergirte” en algunos párrafos; no hay otro modo de leerlos. Pero he intentado reducir el número de esos párrafos. Este libro pretende ser como una colina accesible, mas que una montaña abrumadora.

Esta introducción a la Programación en Emacs Lisp tiene un documento complementario. El Manual de Referencia de GNU Emacs Lisp. El manual de referencia tiene más detalles que esta introducción. En el manual de referencia, toda la información sobre un tema se concentra en un solo lugar. Deberias recurrir a el si eres como el programador citado anteriormente. Y, por supuesto, después de haber leido esta Introducción, encontraras el Manual de Referencia util cuando escribas tus propios programas.

Lisp fué originariamente desarrollado a finales de los años 50 en el Instituto Tecnológico de Massachusetts para la investigacion en inteligencia artificial. El gran poder del lenguaje Lisp lo hace superior también para otros propósitos, como la escritura de comandos de edición y entornos integrados.

GNU Emacs Lisp está fuertemente inspirado en Maclisp, que fue escrito en el MIT en la decada de 1960. Está en cierto modo inspirado en Common Lisp, que se convirtio en un estándar en los 80. Sin embargo, Emacs Lisp es mucho más simple que Common Lisp. (La distribución estándar de Emacs contiene un fichero de extensiones opcional, cl.el, que añade muchas caracteristicas de Common Lisp a Emacs Lisp.)

Si no conoces GNU Emacs, todavia puedes leer este documento provechosamente. Sin embargo, te recomiendo que aprendas Emacs, al menos aprender a moverte alrededor de la pantalla del ordenador. Puedes aprender por ti mismo como usar Emacs con el tutorial incorporado. Para usarlo, escribe C-h t. (Esto significa que debes presionar la tecla CTRL y la h al mismo tiempo, y luego presionar y soltar t).

Ademas, a menudo me refiero a uno de los comandos estándar de Emacs listando las teclas que se presionan para invocar el comando y, luego dando el nombre del comando entre paréntesis, asi: M-C-\ (indent-region). Esto significa invocar el comando indent-region presionando M-C-\. (Puedes, Si lo deseas, cambiar las teclas que se presionan para invocar el comando; esto se denomina rebinding. Consulta la Sección Mapas de teclado.) La abreviatura M-C-\ significa que debes presionar la tecla META, CTRL, y \ al mismo tiempo. (En muchos teclados modernos la tecla META se llama ALT.) Algunas veces una combinación como esta se llama un acorde de teclas, puesto que es similar a tocar un acorde en un piano. Si el teclado no tiene una tecla META, en su lugar se usa la tecla ESC como prefijo. En este caso M-C-\ significa que se presiona y libera ESC y luego se presionan la tecla CTRL y la tecla \ al mismo tiempo. Pero normalmente M-C-\ significa presionar la tecla CTRL junto a la tecla que está marcada como ALT y, al mismo tiempo, presionar la tecla \.

Además de pulsar una sola combinación de teclas, puedes prefijar lo que escribes con C-u, que se llama el ‘argumento universal’. El atajo C-u pasa un argumento al siguiente comando. Por lo tanto, para indentar una región de texto plano por 6 espacios, marca la región, y lugo presiona C-u 6 M-C-\. (Si no se especifica un número, Emacs pasa el número 4 al comando o ejecuta el comando de forma diferente a como lo haria de otro modo). Consulta la Sección Argumentos Numéricos en El Manual de GNU Emacs.

Si estás leyendo esto en Info usando GNU Emacs, puedes avanzar a través de todo este documento presionando la barra espaciadora, SPC. (Para aprender acerca de Info, presiona C-h i y luego selecciona Info.)

Una nota sobre terminología: cuando uso la palabra Lisp sola, con frecuencia me estoy refiriendo a los diversos dialectos de Lisp en general, pero cuando hablo de Emacs Lisp, me estoy refiriendo a GNU Emacs Lisp en particular.

Estoy agradecido a todos los que me ayudaron con este libro. Mi especial agradecimiento a Jim Blandy, Noah Friedman, Jim Kingdon, Roland McGrath, Frank Ritter, Randy Smith, Richard M. Stallman, y Melissa Weisshaus. Gracias también a Philip Johnson y David Stampe por su paciente aliento. Mis errores son míos.

Para el ojo inexperto, Lisp es un lenguaje de programación extraño. En código Lisp hay paréntesis por todas partes. Algunas personas incluso afirman que el nombre signfica ‘Lots of Isolated Silly Parentheses’ (‘Montones de Paréntesis Aislados Estúpidos’). Pero el reclamo es injustificado. Lisp significa LISt Processing, y el lenguaje de programación maneja listas (y listas de listas) poniéndolas entre paréntesis. Los paréntesis marcan los límites de la lista. Algunas veces una lista va precedida por un apóstrofe simple o una marca de cita, ‘'’¹. Las listas son el fundamento de Lisp.

En Lisp, una lista tiene el siguiente aspecto: '(rosa violeta margarita tulipan). Esta lista es precedida por una comilla. Bien, podría estar escrita de la siguiende manera, que se parece mas al tipo de lista con la que probablemente estes familiarizado:

'(rosa
  violeta
  margarita
  tulipan)

Los elementos de esta lista son los nombres de 4 flores diferentes, separados por espacios en blanco y rodeados de paréntesis, como flores en un campo con un muro de piedras a su alrededor.

Las listas también pueden tener números, como en esta lista: (+ 2 2). Esta lista tiene un signo más, ‘+’, seguido por dos ‘2’, cada uno separado por espacios en blanco.

En Lisp, tanto datos como programas se representan de la misma manera; es decir, son a la vez listas de palabras, números, u otras listas, separadas por espacios en blanco y rodeadas de paréntesis. (Puesto que un programa se parece a los datos, un programa puede servir fácilmente como datos para otros; esta es un caracteristica muy poderosa de Lisp.) (A proposito, estas dos marcas de paréntesis no son listas Lisp, porque contienen ‘;’ y ‘.’ como signos de puntuación.)

Aquí hay otra lista, esta vez con una lista dentro de ella:

'(esta lista tiene (una lista dentro de ella))

Los componentes de esta lista son las palabras ‘esta’, ‘lista’, ‘tiene’, y la lista ‘(una lista dentro de ella)’. La lista interior se construye con las palabras ‘una’, ‘lista’, ‘dentro’, ‘de’, ‘ella’.

En Lisp, lo que hemos estado llamando palabras son en realidad átomos. Este término proviene del significado historico de la palabra átomo, que significa ‘indivisible’. En lo que a Lisp concierne, las palabras que hemos estado usando en las listas no se pueden dividir en partes mas pequeñas, sin perder su significado dentro del programa; lo mismo ocurre con números y símbolos de un caracterer como ‘+’. Por otro lado, a diferencia de un átomo antiguo, una lista puede dividirse en partes. Consulta la seccion car, cdr, cons: Funciones fundamentales.

En una lista, los átomos se separan unos de otros por espacios en blanco. Pueden estar justo al lado de un paréntesis.

Técnicamente hablando, una lista en Lisp consiste en paréntesis que rodean átomos separados por espacios en blanco o alrededor de otras lista o alrededor de ambos átomos y otras listas. Una lista puede tener solo un átomo o no tener absolutamente nada en ella. Una lista con nada dentro se ve así: (), y se llama lista vacía. A diferencia de cualquier otra cosa, una lista vacía es tanto un átomo, como una lista al mismo tiempo.

La representación impresa de átomos y listas se llaman expresiones simbólicas o, más concisamente, expresiones-s. La palabra expresión por sí misma puede referirse o bien a la representación impresa, o al átomo o a la lista tal como se encuentra internamente en el ordenador. Con frecuencia, la gente usan el término expresión indiscriminadamente. (Ademas, en muchos textos, la palabra forma se usa como un sinónimo de expresión.)

Por cierto, los átomos que componen nuestro universo fueron nombrados asi cuando se pensaba que eran indivisibles; pero se ha descubierto que los átomos fisicos no son indivisibles. Las partes pueden dividir un átomo o puede fisionarse en 2 partes de igual tamaño. Los átomos físicos se nombraron prematuramente, antes de que su verdadera naturaleza fuese encontrada. En Lisp, ciertos tipos de átomos, como un array, pueden ser separados en partes; pero el mecanismo de hacer esto es diferente del mecanismo para dividir una lista. En lo que se refiere a las operaciones de lista, los átomos de una lista son indivisibles.

Al igual que en el español, el significado de las letras que componen un átomo Lisp difieren del significado de las letras compuestas como una palabra. Por ejemplo, la expresión ‘ay’, es completamente diferente de las dos palabras ‘a’, e ‘y’.

Hay muchos tipos de átomos en la naturaleza, pero solo unos pocos en Lisp: por ejemplo, los números, como 37, 511, o 1729, y los símbolos, como ‘+’, ‘foo’, o ‘forward-line’. Las palabras que hemos listado en los ejemplos anteriores son todos símbolos. En las conversaciones cotidianas de Lisp, la palabra “átomo” no se usa con frecuencia, porque los programadores normalmente intentan ser más específicos acerca del tipo de átomo que están tratando. La programación Lisp es mayormente sobre símbolos (y algunas veces números) dentro de listas. (De ese modo, tres palabras rodeadas de paréntesis son una lista apropiada en Lisp, ya que consiste de átomos, que en este caso son símbolos, separados por espacios en blanco y encerrados entre paréntesis, sin ninguna puntuacion ajena a Lisp.)

El texto entre comillas––incluso oraciones o párrafos––son también un átomo. Aquí hay un ejemplo:

'(esta lista incluye "texto entre comillas.")

En Lisp, todo el texto entre comillas, incluyendo la marca de puntuación y los espacios en blanco, son un unico átomo. Este tipo de átomo se llama string (cadena), por ‘cadena de caracteres’) y es el tipo de cosa que se utiliza para los mensajes que un ordenador puede imprimir para que los lea un humano. Las cadenas son un tipo de átomo diferente a los números, o símbolos y se usan de manera diferente.

La cantidad de espacios en blanco en una lista no importa. Desde el punto de vista del lenguaje Lisp,

'(esta lista
   se ve asi)

es exactamente lo mismo que esto:

'(esta lista se ve asi)

Ambos ejemplos muestran lo que para Lisp es la misma lista, la lista compuesta por los símbolos ‘esta’, ‘lista’, ‘se’, ‘ve’, y ‘asi’ en ese orden.

Los espacios en blanco adicionales y los saltos de línea están diseñados para crear una lista más legible para los humanos. Cuando Lisp lee la expresión, se deshace de todos los espacios en blanco adicionales (pero necesita tener al menos un espacio entre los átomos para poder distinguirlos.)

Por extraño que parezca, los ejemplos que hemos visto cubren casi todos los aspectos de las listas de Lisp. Cualquier otra lista en Lisp se ve más o menos igual a uno de estos ejemplos, excepto que la lista puede ser más larga y compleja. En resumen, una lista está entre paréntesis, una cadena entre comillas, un símbolo se parece a una palabra, y un número a un número. (Para ciertas situaciones, es pueden utilizar corchetes, puntos y otros caracteres especiales; sin embargo; iremos bastante lejos sin ellos.)

Cuando se escribe una expresión Lisp en GNU Emacs usando el modo de Interacción Lisp o el modo Emacs Lisp, están disponibles varios comandos para formatear la expresión Lisp, de modo que sea fácil de leer. Por ejemplo, presionando la tecla TAB automáticamente se indenta la línea donde se encuentra el cursor a la cantidad correcta. Un comando para indentar apropiadamente el código en una región suele vincularse a M-C-\. La indentación está diseñada de modo que se pueda ver qué elementos pertenecen a cada lista––los elementos de una sublista están más indentados que los elementos de la lista adjunta.

Además, al escribir un paréntesis de cierre, Emacs mueve el cursor momentáneamente hacia el parentesis de apertura correspondiente, para que puedas ver cual es. Esto es muy útil, ya que cada lista que escribas en Lisp debe tener su paréntesis de cierre que coincida con su paréntesis de apertura. (Consulta la Seccion Modos Mayores en El Manual de GNU Emacs, para más información sobre los modos de Emacs.)

Una lista en Lisp––cualquier lista––es un programa listo para ejecutarse. Si lo ejecutas (lo que la jerga Lisp llama evaluar), el ordenador hará una de tres cosas: nada excepto devolverte la lista misma; enviar un mensaje de error; o, tomar el primer símbolo en la lista como un comando para hacer alguna cosa. (¡Normalmente, por supuesto, es la última de estas tres cosas lo que realmente quieres!).

El apóstrofe, ', que puse delante de algunas de las listas de ejemplo en las secciones anteriores se llama quote (citar); cuando precede a una lista, le dice a Lisp que no haga nada con la lista, mas que tomarla tal como está escrita. Pero si no hay una cita precediendo la lista, el primer elemento de la lista es especial: es un comando que el ordenador debe obedecer. (En Lisp, estos comandos se llaman funciones.) La lista (+ 2 2) mostrada a continuación no tiene una cita delante de ella, por lo que Lisp comprende que + es una instrucción para hacer alguna cosa con el resto de la lista: sumar los números que siguen.

Si estás leyendo esto dentro de GNU Emacs, aquí está como puedes evaluar tal lista: coloca tu cursor justo después del paréntesis derecho de la siguiente lista y presiona C-x C-e:

(+ 2 2)

Verás que el número 4 aparece en el área eco. (En la jerga, lo que acabas de hacer es “evaluar la lista.” El área de eco es la línea en la parte inferior de la pantalla que muestra o hace “eco” del texto.) Ahora intenta lo mismo con una lista con cita: coloca el cursor justo después de la siguiente lista y presiona C-x C-e:

'(esto es una lista citada)

Verás aparecer (esto es una lista citada) en el área eco.

En ambos casos, lo que estás haciendo es dar un comando al programa dentro de GNU Emacs llamado intérprete Lisp––dando al intérprete un comando para evaluar la expresión. El nombre del intérprete Lisp viene de la palabra para la tarea realizada por un humano que viene con el significado de una expresión––quien lo “interpreta”.

También puedes evaluar un átomo que no es parte de una lista––uno que no está rodeado por paréntesis; una vez mas, el intérprete Lisp traduce desde la expresión humanamente legible al lenguaje del ordenador. Pero antes de discutir esto (consulta la Seccion Variables), veremos lo que hace intérprete de Lisp cuando cometes un el error.

En parte para que no te preocupes si generas un mensaje de error de manera accidental, ahora daremos un comando al intérprete de Lisp que genera un mensaje de error. Esta es una accion inofensiva; y de hecho, a menudo intentaremos generar mensajes de error de manera intencional. Una vez se entiende la jerga, los mensajes de error pueden ser informativos. En lugar de llamarse mensajes de “error”, deberían llamarse mensajes de “ayuda”. Son como señales para un viajero en un país extraño; descifrarlas puede ser dificil, pero una vez se comprenden, pueden señalar el camino.

El mensaje de error es generado por un depurador de codigo incorporado dentro de GNU Emacs. Vamos a ‘entrar al depurador’. Para salir del depurador, presiona q.

Lo que vamos a hacer es evaluar una lista que no tiene cita y que no tiene un comando con significado como primer elemento. Aquí hay una lista casi exactamente igual a la que acabamos de usar, pero sin la cita al inicio. Coloca el cursor a la derecha donde esta finaliza y presiona C-x C-e:

(esto es una lista sin cita)

Se abrirá una ventana *Backtrace* y deberias ver lo siguiente:

---------- Buffer: *Backtrace* ----------
Debugger entered--Lisp error: (void-function esto)
  (esto es una lista sin cita)
  eval((esto es una lista sin cita) nil)
  eval-last-sexp-1(nil)
  eval-last-sexp(nil)
  call-interactively(eval-last-sexp nil nil)
  command-execute(eval-last-sexp)
---------- Buffer: *Backtrace* ----------

Tu cursor estará en esta ventana (es posible que tengas que esperar unos pocos segundos antes de que se haga visible). Para salir del depurador y hacer que su ventana desaparezca, presiona: q

Por favor, ahora presiona q, para que puedas comprobar que se puede salir del depurador. A continuacion, presiona C-x C-e una vez mas para re-entrar.

Basandonos en lo que ya sabemos, casi podemos leer este mensaje de error.

Leyendo el búfer *Backtrace* desde abajo hacia arriba; dice lo que hizo Emacs. Cuando presionaste C-x C-e, se hiso una llamada interactiva al comando eval-last-sexp. eval es una abreviatura para ‘evaluar’ y sexp es una abreviatura para ‘expresión simbólica’. El comando significa ‘evalúa la última expresión simbólica’, que es la expresión inmediatamente anterior al cursor.

Cada linea sobre esta cuenta lo que el intérprete Lisp evaluo a continuacion. La acción más reciente está en la parte superior. El búfer se llama *Backtrace* por que permite realizar un seguimiento de Emacs hacia atrás.

En la parte superior del búfer *Backtrace*, verás la línea:

Debugger entered--Lisp error: (void-function esto)

El intérprete Lisp intentó evaluar el primer átomo de la lista, la palabra ‘esto’. Es esta acción la que genero el mensaje de error ‘void-function esto’.

El mensaje contiene las palabras ‘void-function’ y ‘esto’.

La palabra ‘function’ (función) fué mencionada antes. Es una palabra muy importante. Para nuestros propósitos, podemos definirla diciendo que una función es un conjunto de instrucciones para decirle al ordenador que haga alguna cosa.

Ahora podemos empezar a entender el mensaje de error: ‘void-function esto’. La función (es decir, la palabra ‘esto’) no tiene una definición de ningun conjunto de instrucciones que el ordenador pueda realizar.

La palabra ligeramente extraña, ‘void-function’, está diseñada para cubrir la forma en que Emacs Lisp lo implementa, que es cuando un símbolo no tiene una definición de función adjunta, el sitio que contiene la instruccion esta ‘vacio’ (void).

Por otro lado, ya que fuimos capaces de sumar 2 más 2 de manera exitosa, evaluando (+ 2 2), se puede inferir que el símbolo + debe tener un conjunto de instrucciones que el ordenador ejecuta y estas instrucciones deben ser para sumar los números despues del +.

Es posible evitar que Emacs entre en el depurador en casos como este. No se explicará cómo hacer esto aquí, pero mencionamos como se ve el resultado, porque puede que te encuentres con una situación similar si hay un error en algún código de Emacs que estes usando. En tales casos, solo verá una línea de mensaje de error; aparecera en el área de eco con el siguente aspecto:

Symbol's function definition is void: esto

El mensaje desaparece tan pronto se presione una tecla, aunque sólo sea para mover el cursor.

Conocemos el significado de la palabra ‘Symbol’. Se refiere al primer átomo de la lista, la palabra ‘esto’. La palabra ‘function’ se refiere a las instrucciones que indican al ordenador que hacer. (Técnicamente, el símbolo le indica al ordenador donde encontrar las instrucciones, pero esta es una complicación que podemos ignorar por el momento.)

El mensaje de error es comprensible: ‘La definición del símbolo está vacía: esto’. El símbolo (que es, la palabra ‘esto’) carece de instrucciones para que el ordenador las lleve a cabo.

Podemos articular otra característica de Lisp basada en lo que hemos discutido hasta ahora––una característica importante: un símbolo, como +, no es en sí mismo el conjunto de instrucciones que el ordenador lleva a cabo. En su lugar, el símbolo se utiliza, quizás temporalmente, como una forma de localizar la definición o conjunto de instrucciones. Lo que vemos es el nombre con el cual se pueden encontrar las instrucciones. Los nombres de las personas funcionan de la misma manera. Por ejemplo puedo ser referido como ‘Bob’; sin embargo, no soy las letras ‘B’, ‘o’, ‘b’ pero soy, o fuí, conscientemente asociado con una forma de vida en particular. El nombre no soy yo, pero puede ser usado para referirse a mi.

En Lisp, un conjunto de instrucciones puede ligarse a varios nombres. Por ejemplo, las instrucciones para sumar números se pueden ligar al símbolo mas asi como al símbolo + (y se encuentran en algunos dialectos de Lisp). Entre los humanos, puede referirse a ‘Robert’ tan bien como ‘Bob’ y con otras palabras también.

Por otra parte, un símbolo solo puede estar ligado con una definicion de función a la vez. De lo contrario, el ordenador estaría confundido en cuanto a qué definición usar. Si este fuera el caso entre las gente, solo una persona en el mundo podría llamarse ‘Bob’. Sin embargo, la definición de función a la que el nombre hace referencia puede cambiarse fácilmente. (Consulta la Sección Instalar una Definición de Función.)

Ya que Emacs Lisp es extenso, se acostumbra nombrar los símbolos de una forma que identifique la parte de Emacs a la que pertenece la función. En consecuencia, todos los nombres de funciones relacionadas con Texinfo comienzan con ‘texinfo-’ y aquellas relacionadas con la lectura de correo empiezan con ‘rmail-’.

Basado en lo que hemos visto, ahora podemos empezar a entender lo que hace el intéprete Lisp cuando le ordenamos que evalue una lista. Primero, examina si hay un símbolo de cita antes de la lista; si lo hay, el intérprete solo nos da la lista. Por otra parte, si no hay cita, el intéprete mira si el primer elemento de la lista tiene una definición de función. De lo contrario, el intérprete imprime un mensaje de error.

Así es como funciona Lisp. Simple. Hay complicaciones añadidas a las que llegaremos en un minuto, pero estos son los fundamentos. Por supuesto, para escribir programas Lisp, se necesita saber como escribir definiciones de función y vincularlas a nombres, y como hacer esto sin confundirnos a nosotros mismos o al ordenador.

Ahora, una primera complicación. Además de las listas, el intérprete Lisp puede evaluar un símbolo sin citar y que no tiene paréntesis en torno a el. El intérprete intentará determinar el valor del símbolo como una variable. Esta situación se describe en el apartado de las variables. (Consulta la Seccion Variables.)

La segunda complicación ocurre debido a que algunas funciones son inusuales y no funcionan de la manera habitual. Estas se llaman formas especiales (special forms). Se utilizan para trabajos especiales, como definir una función, y no hay muchas de ellas. En los siguientes capítulos, se presentaran varias de las formas especiales más importantes.

La tercera y ultima complicación es la siguiente: si la función que el intérprete Lisp está examinando no es una forma especial, y si es parte de una lista, el intérprete Lisp mira si la lista tiene una lista dentro de ella. Si existe una lista interna, el intérprete Lisp primero determina lo qué debe hacer con la lista interna, y luego trabaja en la lista externa. Si hay otra lista incrustada dentro de la lista interna, trabaja en esta primero, y así sucesivamente. Siempre se trabaja en la lista mas interna primero. El interprete trabaja primero en la lista más interana, para evaluar el resultado de esa lista. El resultado puede ser usado por la expresión entre paréntesis.

Por lo demas, el intérprete trabaja de izquierda a derecha, de una expresión a la siguiente.

Otro aspecto de la interpretación: el intérprete Lisp es capaz de interpretar dos tipos de entidades: código humanamente legible, en el que nos centraremos exclusivamente, y código especialmente procesado, llamado compilado, que no es humanamente legible. El código compilado se ejecuta más rápido que el código legible humanamente.

Tu puedes transformar código legible por humanos en código compilado ejecutando uno de los comandos de compilación como byte-compile-file. El código compilado se almacena normalmente en un fichero que finaliza con una extensión .elc en lugar de una extensión .el. Verás ambos tipos de ficheros en el directorio emacs/lisp; los ficheros para leer son aquellos con la extensión .el.

Como una cuestión práctica, para hacer la mayoría de las cosas como personalizar o extender Emacs, no necesitas compilar codigo; y no comentare el asunto aquí. Consulta la Seccion Código Compilado en El Manual de Referencia de GNU Emacs Lisp, para una descripción completa de la compilacion de código.

Cuando el intérprete Lisp trabaja en una expresión, el término para la esa actividad se llama evaluación. Decimos que el intérprete ‘evalúa la expresión’. He usado este término varias veces antes. La palabra proviene de su uso en el lenguaje cotidiano, ‘para determinar el valor o la cantidad de; para evaluar’ segun el Webster's New Collegiate Dictionary.

Después de evaluar una expresión, es muy probable que el intérprete Lisp devuelva el valor que el ordenador produce al ejecutar las instrucciones que encuentra en la definición de la función, o quizás se de por vencido con en esa función y produzca un mensaje de error. (El intérprete también puede quedarse colgado, por así decirlo, a una función diferente o puede intentar repetir continuamente lo que está haciendo por siempre en lo que se llama un ‘bucle infinito’. Estas acciones son menos comunes; y podemos ignorarlas). Con mas frecuencia, el intérprete devuelve un valor.

Al mismo tiempo que el intérprete devuelve un valor, también puede realizar cualquier otra cosa, como mover un cursor o copiar un fichero; este otro tipo de acción se denomina efecto secundario. Acciones que los humanos pensamos que son importantes, como imprimir resultados, con frecuencia son, “efectos secundarios” para el intérprete Lisp. La jerga puede sonar peculiar, pero resulta que es bastante fácil aprender a utilizar los efectos secundarios.

En resumen, la evaluacion de una expresión simbólica normalmente causa que el intérprete devuelva un valor y tal vez lleve a cabo un efecto secundario; o al menos produca un error.

Si la evaluación se aplica a una lista que está dentro de otra lista, la lista externa puede usar el valor devuelto por la primer evaluación como información cuando se evalua la lista externa. Esto explica por qué las expresiones internas se evaluan primero: los valores devueltos son usados por las expresiones externas.

Podemos investigar este proceso evaluando otro ejemplo de sumas. Coloca tu cursor después de la siguiente expresión y presiona C-x C-e:

(+ 2 (+ 3 3))

El número 8 aparecerá en el área de eco.

Lo que ocurre es que el intérprete Lisp primero evalúa la expresión interna, (+ 3 3), para lo cual se devuelve el valor 6; luego evalúa la expresión externa como si fuera escrita (+ 2 6), que devuelve el valor 8. Puesto que no hay más expresiones adjuntas a evaluar el intérprete imprime este valor en el área de eco.

Ahora es fácil comprender el nombre del comando invocado por el atajo C-x C-e: el nombre es eval-last-sexp. Las letras sexp son una abreviatura de ‘expresión simbólica’ (symbolic expression), y eval es una abreviatura de ‘evaluar’ (evaluate). El comando significa ‘evaluar la última expresión simbólica’.

Como un experimento, puedes intentar evaluar la expresión poniendo el cursor al principio de la siguiente línea inmediatamente después de la expresión, o dentro de la expresión.

Aquí hay otra copia de la expresión:

(+ 2 (+ 3 3))

Si colocas el cursor al principio de la línea en blanco que sigue inmediatamente a la expresión y presionas C-x C-e, aún obtendrás el valor 8 impreso en el área eco. Ahora coloca el cursor dentro de la expresión. Si lo pones justo después del penúltimo paréntesis (de modo que parezca estar sobre el último paréntesis), ¡obtendrás un 6 impreso en el área de eco! Esto se debe a que el comando evalúa la expresión (+ 3 3).

Ahora coloca el cursor inmediatamente después de un número. Presiona C-x C-e y obtendras el número en sí. En Lisp, si evalúas un número, obtienes el número en sí––así es cómo los números difieren de los símbolos. Si evalúas una lista que inicia con un símbolo como +, obtendras un valor devuelto que es el resultado del ordenador tras ejecutar las instrucciones que aparecen en la definición de la función ligada a ese nombre. Si se evalua un símbolo por sí mismo, sucede algo diferente, como veremos en la siguiente sección.

En Emacs Lisp, un símbolo puede estar ligado a un valor como a una definición de función. Los dos son diferentes. La definición de función es un conjunto de instrucciones que el ordenador ejecuta. Un valor, por otro lado, es algo, como un número o un nombre, que puede variar (razon por la cual tal símbolo se llama variable). El valor de un símbolo puede ser cualquier expresión de Lisp, por ejemplo un símbolo, un número, una lista, o una cadena. Un símbolo que tiene un valor con frecuencia se llama variable.

Un símbolo puede ser tanto una definición de función como un valor asociado a el al mismo tiempo. O puede tener uno u otro. Los dos son independientes. Esto es algo similar a la forma en que el nombre Cambridge puede referirse a la ciudad en Massachusetts y tener alguna información ligada al nombre, por ejemplo, como “gran centro de programación”.

Otra manera de pensar en esto es imaginar un símbolo como un mueble con cajones. La definición de función se coloca en un cajón, el valor en otro, etcetera. Lo que se pone en el cajón que contiene el valor se puede cambiar sin afectar el contenido del cajón que almacena la definición de función, y viceversa.

La variable fill-column ilustra un símbolo con un valor adjunto: en cada buffer de GNU Emacs, este símbolo se establece en algún valor, normalmente 72 o 70, pero algunas veces en algún otro valor. Para encontrar el valor de este símbolo, evalúalo por sí mismo. Si estás leyendo esto dentro de GNU Emacs, puedes hacerlo poniendo el cursor después del símbolo y pulsando C-x C-e:

fill-column

Después de presionar C-x C-e, Emacs imprimió el número 72 en mi área de eco. Este es el valor que he establecido para fill-column mientras escribo esto. Puede ser diferente en tu búfer. Observa que el valor devuelto como una variable se imprime exactamente de la misma forma que el valor devuelto por una función tras ejecutar sus instrucciones. Desde el punto de vista del intérprete Lisp, un valor devuelto es un valor devuelto. La clase de expresion de la que proviene deja de importar una vez se conoce el valor.

Un símbolo puede tener cualquier valor ligado a él o, siendo tecnicos, se puede enlazar la variable a un valor: a un número, por ejemplo 72; a una cadena, "como esta"; a una lista, como (abeto pino roble); podemos incluso asociar una variable a una definición de función.

Un símbolo puede vincularse a un valor de varias maneras. Consulta la Sección Establecer el valor de una variable, para obtener información sobre como hacerlo.

Cuando evaluamos fill-column para encontrar su valor como una variable, no pusimos paréntesis alrededor de la palabra. Esto se debe a que no pretendiamos usarla como nombre de función.

Si fill-column fuese el primer o único elemento de una lista, el intérprete Lisp intentaría encontrar la definición de función adjunta. Pero fill-column no tiene una definición de función. Intenta evaluar esto:

(fill-column)

Se creará un buffer *Backtrace* que dice:

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

(Recuerda, para salir del depurador y hacer que la ventana del depurador desaparezca, presiona q en el buffer *Backtrace*.)

Si intentas evaluar un símbolo que no tiene un valor asociado, recibirás un mensaje de error. Esto se puede ver experimentando con nuestra suma 2 más 2. En la siguiente expresión, coloca el cursor justo después del +, antes del primer número 2, presiona C-x C-e:

(+ 2 2)

En GNU Emacs 22, se creará un buffer *Backtrace* que dice:

---------- Buffer: *Backtrace* ----------
Debugger entered--Lisp error: (void-variable +)
  eval(+ 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* ----------

(De nuevo, puedes salir del depurador pulsando q en el búfer *Backtrace*.)

Esta traza inversa es diferente del primer mensaje de error que vimos, que decia, ‘Debugger entered--Lisp error: (void-function esto)’. En este caso, la función no tiene una valor como variable; mientras en el otro mensaje de error, la función (la palabra ‘esto’) no tenia una definición.

En este experimento con el +, lo que hicimos fué hacer que el intérprete Lisp evalúe el + y busque el valor de la variable en lugar de la definición de la función. Hicimos esto colocando el cursor justo después del símbolo en lugar de ponerlo al final de los parentesis que cierran la lista como hicimos antes. Como consecuencia, el intérprete Lisp evaluó la expresión-s precedente, que en este caso era el + en sí.

Ya que + no tiene un valor asociado, solo la definición de función, el mensaje de error informaba que el valor del símbolo como una variable esta vacío.

Para ver cómo se pasa la información a las funciones, veamos de nuevo nuestro viejo recurso, la suma de dos más dos. En Lisp, esto se escribe de la siguiente manera:

(+ 2 2)

Si evalúas esta expresión, el número 4 aparecerá en el área de eco. Lo que el intérprete de Lisp hace es sumar los números despues del +.

Los números sumados por + se llaman argumentos de la función +. Estos números son la información que se da o se pasa a la función.

La palabra ‘argumento’ proviene de la forma en que se usa en matemáticas y no se refiere a una disputa entre dos personas, En su lugar, se refiere a la información entregada a la función, en este caso, al +. En Lisp, los argumentos de una función son los átomos o listas que siguen a la función. Los valores devueltos por la evaluación de estos átomos o listas se transfieren a la función. Funciones diferentes requieren diferentes números de argumentos; algunas funciones no requieren ninguno en absoluto.²

El tipo de datos que deben pasarse a una función dependen del tipo de información que utilice. Los argumentos de una función como + deben tener valores númericos, ya que + suma números. Otras funciones utilizan diferentes tipos de datos para sus argumentos.

Por ejemplo, la función concat concatena o une dos o más cadenas de texto para producir una cadena. Los argumentos son cadenas. Concatenar las cadenas de caracteres abc, def produce una cadena abcdef. Esto se puede ver evaluando lo siguiente:

(concat "abc" "def")

El valor producido al evaluar esta expresión es "abcdef".

Una función como substring utiliza tanto una cadena como numeros como argumentos. La función devuelve una parte de la cadena, una subcadena del primer argumento. Esta función toma tres argumentos. Su primer argumento es la cadena de caracteres, el segundo y tercer argumento son números que indican el principio y el fin de la subcadena. Los números son un recuento del número de caracteres (incluyendo espacios y si signos de puntuacion) desde el principio de la cadena.

Por ejemplo, si evalúas lo siguiente:

(substring "El rápido zorro marrón saltó." 10 15)

Veras aparecer "zorro" en el área de eco. Los argumentos son la cadena y los dos números.

Ten en cuenta que la cadena pasada a substring es un unico átomo a pesar de estar compuesto de varias palabras separadas por espacios. Lisp considera todo entre las dos comillas como parte de la cadena, incluyendo los espacios. Puedes pensar en la función substring como una especie de ‘acelerador de particulas’ ya que toma un átomo de otro modo indivisible y extrae una parte. Sin embargo, substring solo es capaz de extraer una subcadena de un argumento que es una cadena, no de otro tipo de átomo por ejemplo un número o símbolo.

Un argumento puede ser un símbolo que devuelve un valor cuando se evalua. Por ejemplo, evaluar el símbolo fill-column en si mismo, devuelve un número. Este número se puede utilizar en una suma.

Coloca el cursor después de la siguiente expresión y presiona C-x C-e:

(+ 2 fill-column)

El valor será dos mas el número que se obtiene evaluando fill-column. En mí caso, es 74, porque mi valor de fill-column es 72.

Como acabamos de ver, un argumento puede ser un símbolo que devuelve un valor cuando se evalúa. Además, un argumento puede ser una lista que devuelve un valor cuando se evalúa. Por ejemplo, en la siguiente expresión, los argumentos de la función concat son las cadenas "Los " y " zorros rojos." y la lista (number-to-string (+ 2 fill-column)).

(concat "Los " (number-to-string (+ 2 fill-column)) " zorros rojos.")

Si evaluas esta expresión––y si, como con mi Emacs, fill-column se evalúa a 72––aparecerá "Los 74 zorros rojos." en el área de eco. (Ten en cuenta que debes poner espacios después de la palabra ‘Los’ y antes de la palabra ‘zorros’ para que aparezcan en la cadena final. La función number-to-string convierte el entero que devuelve la función suma a una cadena. number-to-string también se conoce como int-to-string.)

Algunas funciones, como concat, +, o *, toman cualquier número de argumentos. (* es el símbolo para la multiplicacion.) Esto se puede ver evaluando cada una de las siguientes expresiones de la forma habitual.

En el primer conjunto, las funciones no tienen argumentos:

> (+)
0
> (*)
1

En este conjunto, las funciones tienen un argumento cada una:

> (+ 3)
3
> (* 3)
3

En este conjunto, las funciones tienen tres argumentos cada una:

> (+ 3 4 5)
12
> (* 3 4 5)
60

Cuando a una función se le pasa un argumento del tipo incorrecto, el interpréte Lisp produce un mensaje de error. Por ejemplo, la función + espera que los valores de sus argumentos sean números. Como un experimento podemos pasar el símbolo citado hola en lugar de un número. Coloca el cursor después de la siguiente expresión y presiona C-x C-e:

(+ 2 'hola)

Al hacer esto se generará un mensaje de error. Lo qué ha ocurrido es que + ha intentado sumar el 2 al valor devuelto por 'hola, pero el valor devuelto por 'hola es el símbolo hola, no un número. Solo los números se pueden sumar. Por tanto + no pudo llevar a cabo su suma.

Se creará e ingresara a un búfer *Backtrace* que dice:

---------- Buffer: *Backtrace* ----------
Debugger entered--Lisp error: (wrong-type-argument number-or-marker-p hola)
  +(2 hola)
  eval((+ 2 (quote hola)) nil)
  eval-last-sexp-1(nil)
  eval-last-sexp(nil)
  call-interactively(eval-last-sexp nil nil)
  command-execute(eval-last-sexp)
---------- Buffer: *Backtrace* ----------

Como de costumbre, el mensaje de error intenta ser útil y tiene sentido después de aprender a leerlo.³

La primer parte del mensaje de error es sencilla; dice ‘wrong type argument’ (tipo de argumento incorrecto). A continuación viene la misteriosa jerga tecnica ‘number-or-marker-p’. Esta palabra está intentando decirte qué tipo de argumento espera +.

El símbolo number-or-marker-p dice que el intérprete Lisp está intentando determinar si la información presentada (el valor del argumento) es un número o una marca (un objeto especial que representa una posición de buffer). Lo que hace es probar si se le estan dando numeros a sumar a +. También comprueba si el argumento es algo llamado marcador, que es una caracteristica específica de Emacs Lisp. (En Emacs, las ubicaciones en un búfer se registran como marcadores. Cuando se establece la marca con el comando C-@ o C-SPC, su posición se guarda como un marcador. La marca se puede consider un número––el número de caracteres es la ubicacion desde el principio del búfer.) En Emacs Lisp, + se puede utilizar para sumar el valor numérico de los marcadores como números.

La ‘p’ en number-or-marker-p es la encarnación de una práctica iniciada en los primeros días de la programación Lisp. La ‘p’ significa ‘predicado’. En la jerga usada por los primeros investigadores de Lisp, un predicado se refiere a una función para determinar si alguna propiedad es verdadera o falsa. Entonces la ‘p’ nos dice que number-or-marker-p es el nombre de una función que determina si el argumento dado es un número o un marcador. Otros símbolos Lisp que finalizan en ‘p’ incluyen zerop, una función que comprueba si su argumento tiene el valor de cero, y listp, una función que comprueba si su argumento es una lista.

Finalmente, la última parte del mensaje de error es el símbolo hola. Este es el valor del argumento que se paso a +. Si a la suma se le hubiera pasado el tipo correcto de objeto, el valor habría sido un número, como 37, en lugar de un símbolo como hola. Pero entonces no habrías recibido el mensaje de error.

Al igual que +, la función message toma un número de argumentos variable. Se utiliza para enviar mensajes al usuario y es tan útil que la describiremos aqui.

Se imprime un mensaje en el área de eco. Por ejemplo, puedes imprimir un mensaje en tu área de eco evaluando la siguiente lista:

(message "¡Este mensaje aparece en el área de eco!")

Toda la cadena entre comillas dobles es un unico argumento y se imprime en su totalidad. (Obseva que en este ejemplo, el mensaje mismo aparece en el área de eco entre comillas dobles; esto se debe a que ves el valor devuelto por la función message. En la mayoría de programas que escribiras, el texto se imprimira en el área de eco como un efecto secundario de message, sin las comillas. Consulta la Sección multiplicar-por-siete interactivo, para ver en detalle un ejemplo de esto.)

Sin embargo, si hay un ‘%s’ en la cadena de caracteres entre comillas, la función message no imprime el ‘%s’ como tal, si no que mira el siguente argumento a continuacion de la cadena. Evalúa el segundo argumento e imprime el valor en la ubicación de la cadena donde está el ‘%s’.

Puedes ver esto colocando el cursor después de la siguiente expresión y presionar C-x C-e:

(message "El nombre de este búfer es: %s." (buffer-name))

En Info, "El nombre de este búfer es: *info*." aparecerá en el área de eco. La función buffer-name devuelve el nombre del búfer como una cadena, que la función message inserta en lugar de %s.

Para imprimir un valor como un entero, utiliza ‘%d’ de la misma forma que ‘%s’. Por ejemplo, para imprimir un mensaje en el área de eco que indique el valor de fill-column, evalúa lo siguiente:

(message "El valor de fill-column es %d." fill-column)

En mi sistema, cuando evalúo esta lista, "El valor de fill-column es 72" aparece en mi área de eco⁴.

Si hay más de un ‘%s’ en la cadena entre comillas, el valor del primer argumento después de la cadena se imprime en la posición del primer ‘%s’ y el valor del segundo argumento se imprime en la posición del segundo ‘%s’, y así sucesivamente.

Por ejemplo, si evalúas lo siguiente,

(message "¡Hay %d %s en la oficina!"
         (- fill-column 14) "elefantes rosas")

aparecerán un mensaje un poco caprichoso en el área de eco. En mi sistema dice "¡Hay 58 elefantes rosas en la oficina!"

Se evalúa la expresión (- fill-column 14) y el número resultante se inserta en lugar del ‘%d’; y la cadena entre comillas dobles, "elefantes rosas", se trata como un unico argumento y se inserta en lugar del ‘%s’. (Es decir, una cadena entre comillas dobles se evalúa así misma, como un número.)

Por último, aquí está un ejemplo algo complejo que no solo ilustra el cálculo de un número, sino que también muestra como se puede usar una expresión dentro de una expresión para generar el texto que sustituira el ‘%s’:

(message "Él vió %d %s"
         (- fill-column 36)
         (concat (substring
                  "Los rápidos zorros marrones saltaron." 12 18)
                 " rojos"
                 " saltando."))

En este ejemplo, message tiene tres argumentos: la cadena, "Él vió %d %s", la expresión, (- fill-column 32), y la expresion que comienza con la función concat. El valor resultante de la evaluación de (- fill-column 32) se inserta en lugar del ‘%d’; y el valor devuelto por la expresión que inicia con concat se inserta en lugar del ‘%s’.

Cuando fill-column es 70 y evaluas la expresión, aparecera el mensaje "Él vió 38 zorros rojos saltando." en tu área de eco.

Hay varias formas de asignar un valor a una variable. Una de ellas es utilizar la función set o la función setq. Otra forma es utilizar let (Consulta la Seccion let). (La jerga para este proceso es ligar (bind) una variable a un valor.)

Las siguientes secciones no solo describen cómo operan set y setq, también ilustran como se pasan los argumentos.

Para establecer el valor del símbolo flores a la lista '(rosa violeta margarita tulipan), evalúa la siguiente expresión colocando el cursor después de la expresión y presiona C-x C-e.

(set 'flores '(rosa violeta margarita tulipan))

La lista (rosa violeta margarita tulipan) aparecerá en el área de eco. Esto es la que devuelve la función set. Como efecto secundario, el símbolo flores esta ligado a la lista; es decir, el símbolo flores, puede verse como una variable, que entrega la lista como su valor. (Por cierto, este proceso, ilustra como un efecto secundario del intérprete Lisp, al establecer el valor, puede ser el principal efecto que nos interesa a los humanos. Esto se debe a que cada función Lisp debe devolver un valor si no obtiene un error, pero solo tendrá un efecto secundario si está diseñada para tenerlo.)

Después de evaluar la expresión set, se puede evaluar el símbolo flores y devolvera el valor que se acaba de establecer. Aquí está el símbolo. Coloca el cursor al final de este y presiona C-x C-e.

flores

Al evalúar flores, aparece la lista (rosa violeta margarita tulipan) en el área de eco.

Por cierto, si se evalúa 'flores, la variable con una cita frente a ella, lo que verás en el área de eco es el símbolo en sí mismo, flores. Aquí está el símbolo citado, asi que puedes intentarlo:

'flores

Ten en cuenta también, que cuando se utiliza set, es necesario citar ambos argumentos, a menos que quieras que sean avaluados. Como no queremos que se evalue ninguno de los dos argumentos, se citan tanto la variable flores, como la lista (rosa violeta margarita tulipan). (Cuando se utiliza set sin citar su primer argumento, el primer argumento se evalúa antes de realizar cualquier otra cosa. Si se hace esto y flores no tenía ya un valor, obtendras un mensaje de error de tipo, ‘El valor de símbolo como variable esta vacío’; por otro lado, si flores regresa un valor después de ser evaluada, set intentaría establecer el valor que fue devuelto. Hay situaciones donde esto es justo lo que la función a de hacer, pero estas situaciones son poco frecuentes.)

Como una cuestión práctica, casi siempre se cita el primer argumento de set. La combinación de set y un primer argumento citado es tan común que tiene su propio nombre: la forma especial setq. Esta forma especial es similar a set excepto que el primer argumento se citado automáticamente, por lo que no es necesario escribir la marca de cita. Ademas, como una conveniencia adicional, setq permite asignar varias variables diferentes a diferentes valores, todo en una sola expresión.

Para establecer el valor de la variable carnívoros a la lista '(leon tigre leopardo) usando setq, se utiliza la siguiente expresión:

(setq carnivoros '(leon tigre leopardo))

Esto es exactamente igual que usar set excepto que el primer argumento se cita automáticamente por setq. (La ‘q’ en setq significa quote (cita).)

Con set, la expresión se vería asi:

(set 'carnivoros '(leon tigre leopardo))

Además, setq se puede utilizar para asignar diferentes valores a diferentes variables. El primer argumento se une al valor del segundo argumento, el tercer argumento se une a al valor del cuarto argumento, y así sucesivamente. Por ejemplo, podría utilizar lo siguiente para asignar una lista de árboles al símbolo arboles y una lista de herbívoros al símbolo herbivoros:

(setq arboles '(pino abeto roble arce)
      herbivoros '(gacela antilope cebra))

(La expresión podría también haber estado en una unica línea, pero podría no caber en una página; y a los humanos les resulta más fácil leer listas con un formato agradable.)

Aunque he estado usando el término ‘asignar’, hay otra forma de pensar respecto a el funcionamiento de set y setq; y consiste en decir que set y setq hacen que el símbolo apunte a la lista. Esta ultima forma de pensar es muy común y en los proximos capítulos nos encontraremos con al menos un símbolo que tiene ‘puntero’ como parte de su nombre. El nombre se elige porque el símbolo tiene un valor, específicamente una lista, unida a el; o, expresado de otra manera, el símbolo se establece como “puntero” a la lista.

He aquí un ejemplo que muestra cómo utilizar setq en un contador. Es posible usar esto para contar cuantas veces se repite una parte de un programa. En primer lugar se necesita establecer una variable a cero; luego sumar uno al número cada vez que el programa se repita. Para hacer esto, se requiere una variable que sirva como contador, y dos expresiones: una expresión setq inicial que asigne la variable contador a cero; y una segunda expresión setq que incremente el contador cada vez se evalue.

(setq contador 0)                ; Llamemos a esto el inicializador.

(setq contador (+ contador 1))   ; Este es el incremento.

contador                         ; Este es el contador.

(El texto que sigue al ‘;’ son los comentarios. Consulta la Seccion Cambiar una definición de función.)

Si evalúas la primera de estas expresiones, el inicializador, (setq contador 0), y luego evalúas la tercera expresión, contador, el número 0 aparecerá en el área de eco. Si a continuación se evalúa la segunda expresión, el incremento, (setq contador (+ contador 1)), el contador tendrá el valor 1. Así que si evalúas de nuevo contador, el número 1 aparecerá en el área de eco. Cada vez que se evalúa la segunda expresión, el valor del contador se incrementara.

Al evalúar el incremento, (setq contador (+ contador 1)), el intérprete Lisp evalúa en primer lugar la lista interna; esta es la suma. Para evaluar esta lista, se debe evaluar la variable contador y el número 1. Cuando evalúa la variable contador, recibe su valor actual. Se pasa este valor y el número 1 a + que los suma. La suma se devuelve como el valor de la lista interior y pasa a setq que establece la variable contador a este nuevo valor. Por lo tanto, el valor de la variable contador, cambia.

Aprender Lisp es como subir una colina en la que la primera parte es la mas empinada. Ahora has subido la parte más difícil; lo que queda se vuelve más fácil a medida que avanzas hacia adelante.

En resumen,

• Los programas Lisp se componen de expresiones, que son listas o átomos individuales.

• Las listas se componen de cero o más átomos o listas internas, separadas por espacios en blanco y rodeadas por paréntesis. Una lista puede estar vacía.

• Los átomos son símbolos de varios caracteres, como forward-paragraph, símbolos de un solo caracter como +, cadenas de caracteres entre comillas dobles, o números.

• Un número se evalúa a sí mismo.

• Una cadena entre comillas dobles también se evalúa a sí misma.

• Cuando se evalúa un símbolo en si, se devuelve su valor.

• Cuando se evalúa una lista, el intérprete Lisp mira el primer símbolo en la lista y luego la definición de función asociada a ese símbolo. A continuación se ejecutan las instrucciones en la definición de la función.

• Una marca de cita, ', le indica al intérprete Lisp que devuelva la siguiente expresión tal como esta escrita, y no evaluarla como lo haria si la cita no estuviera alli.

• Los argumentos son la información que se pasa a una función. Los argumentos de una función se calculan evaluando el resto de los elementos de la lista de los cuales la función es el primer elemento.

• Una función siempre devuelve un valor cuando se evalúa (a menos que se produzca un error); además, también se puede llevar a cabo alguna acción llamada “efecto secundario”. En muchos casos, el propósito principal de una función es crear un efecto secundario.

Unos cuantos ejercicios simples:

• Genera un mensaje de error evaluando un símbolo apropiado que no este entre paréntesis.

• Genera un mensaje de error evaluando un símbolo apropiado que se encuentre entre paréntesis.

• Crea un contador que se incrementa en dos en lugar de en uno.

• Escribe una expresión que imprima un mensaje en el área de eco cuando se evalue.

Antes de aprender a escribir una definición de función en Emacs Lisp, es útil dedicar un poco de tiempo a evaluar varias expresiones que ya han sido escritas. Estas expresiones serán listas con funciones como su primer (y con frecuencia único) elemento. Dado que algunas de las funciones asociadas con búfers son a la vez simples e interesantes, empezaremos por ellas. En esta sección, vamos a evaluar algunas. En otra sección, estudiaremos el código de varias otras funciones relacionadas con búfers, para ver la forma cómo fueron escritas.

Siempre que se le da un comando de edición a Emacs Lisp, como el comando para mover el cursor o para desplazarse por la pantalla, se está evaluando una expresión, cuyo primer elemento es una función. Así es cómo funciona Emacs.

Al presionar las teclas, haces que el interprete Lisp evalue una expresion y asi es como obtienes resultados. Incluso escribir texto plano implica evalúar una función de Emacs Lisp, en este caso, se utiliza self-insert-command, que simplemente inserta el caracter que has escrito. Las funciones que se evalúan presionando atajos de teclado se llaman funciones interactivas, o comandos; la forma de hacer que una funcion sea interactiva se ilustrara en el capítulo sobre cómo escribir definiciones de funcion. Consulta la Seccion Crear una Función Interactiva.

Además de presionar comandos de teclado, hemos visto una segunda manera de evaluar una expresión: colocar el cursor después de una lista y presionar C-x C-e. Esto es lo que haremos en el resto de esta sección. Hay otras maneras de evaluar una expresión; estas serán descritas a medida que llegemos a ellas.

Ademas de utilizarlas para prácticar la evaluación, las funciones que se muestran en las siguientes secciones son importantes por derecho propio. Un estudio de estas funciones deja claro la distinción entre búfers y ficheros, cómo cambiar a un búfer, y como determinar una ubicación dentro de el.

Las dos funciones, buffer-name y buffer-file-name, muestran la diferencia entre un fichero y un búfer. Cuando se evalúa la siguiente expresión, (buffer-name), el nombre del buffer aparece en el area eco. Al evaluar (buffer-file-name), el nombre del fichero al que hace referencia el búfer aparece en el área de eco. Por lo general, el nombre devuelto por (buffer-name) es el mismo que el nombre del fichero al que hace referencia, y el nombre devuelto por (buffer-file-name) es la ruta completa del fichero.

Un fichero y un búfer son dos entidades diferentes. Un fichero es la información grabada de manera permanente en el ordenador (a menos que se elimine). Un búfer, por otro lado, es información dentro de Emacs que desaparecerá al final de la sesión de edición (o cuando mates el búfer). Por lo general, un búfer contiene información que se ha copiado desde un fichero; decimos que el búfer está visitando ese fichero. Esta copia es en la que se trabaja y modifica. Los cambios en el búfer no modifican el fichero, hasta guardar el búfer. Al guardar el búfer, el búfer se copia en el fichero y por lo tanto se guarda de forma permanente.

Si está leyendo esto dentro de GNU Emacs, puedes evaluar cada una de las siguientes expresiones colocando el cursor después de estas y pulsando C-x C-e.

(buffer-name)

(buffer-file-name)

Cuando hago esto en el búfer *info*, el valor devuelto evaluando (buffer-name) es "*info*", y el valor devuelto evaluando (buffer-file-name) es nil.

Por otro lado, mientras escribo este documento, el valor devuelto por la evaluación de (buffer-name) es "introduction.texinfo", y el valor evaluando (buffer-file-name) es "/gnu/work/intro/introduction.texinfo".

El primero es el nombre del búfer y el segundo es el nombre del fichero. En Info, el nombre del búfer es "*info*". Info no apunta a ningún fichero, por lo que el resultado de evaluar (buffer-file-name)] es nil. El símbolo nil proviene del latin, significa ‘nada’; en este caso, significa que el búfer no está asociado con ningun fichero. (En Lisp, nil también se utiliza con el significado de ‘falso’ y es sinómino para la lista vacía, ().)

Al escribir esto, el nombre de mi búfer es "introduction.texinfo". El nombre del fichero al que apunta es "/gnu/work/intro/introduction.texinfo".

(En las expresiones, los paréntesis le indican al intérprete Lisp que trate a buffer-name y buffer-file-name como funciones; sin los paréntesis, el intérprete intentaría evaluar los símbolos como variables. Consulta la Sección Variables.)

A pesar de la distinción entre ficheros y búfers, con frecuencia encontraras personas referirse a un fichero cuando se refieren a un búfer y viceversa. De hecho, la mayoría de la gente dice, “Estoy editando un fichero”, en lugar de decir, “Estoy editando un búfer que pronto voy a guardar en un fichero”. Esto casi siempre queda claro a partir del contexto de lo que la gente quiere decir. No obstante, al tratar con programas de ordenador, es importante tener en cuenta la distinción, ya que el ordenador no es tan inteligente como una persona.

Por cierto, la palabra ‘búfer’, viene del significado de la palabra como un cojín que amortigua la fuerza de una colisión. En los primeros ordenadores, un búfer amortiguaba la interacción entre los ficheros y la unidad central de procesamiento del ordenador. Los tambores o cintas que contenian un fichero y la unidad de procesamiento eran equipos muy diferentes entre si, que trabajaban a su propia velocidad, por rafagas. El búfer hizo posible que ambos trabajaran juntos de manera efectiva. Con el tiempo, el búfer pasó de ser un intermediario, un lugar de almacenamiento temporal, a ser el lugar donde se realiza el trabajo. Esta transformación se parace bastante a la de un pequeño puerto que se convierte en una gran ciudad: una vez fué simplemente el lugar donde la carga se almacenaba temporalmente antes de ser cargada en los barcos; despues se convirtio en un centro comercial y cultural por derecho propio.

No todos los búfers están asociados con ficheros. Por ejemplo, el búfer *scratch* no visita ningun fichero. Del mismo modo, un búfer *Help* no está asociado a ningun fichero.

En los viejos tiempos, cuando se carecia de un fichero ~/.emacs y se iniciaba una sesión Emacs escribiendo unicamente el comando emacs, sin nombrar ningun fichero, Emacs iniciaba con el búfer *scratch* visible. Hoy en día, veras una pantalla de bienvenida. Puedes seguir uno de los comandos sugeridos en dicha pantalla, visitar un fichero, o presionar la barra de espacio para acceder al búfer *scratch*.

Si cambias al búfer *scratch*, escribe (buffer-name), coloca el cursor al final de la expresión, y presiona C-x C-e para evaluar la expresión. El nombre *scratch* será devuelto y aparecerá en el área de eco. *scratch* es el nombre del búfer. Al escribir y evaluar (buffer-file-name) en el búfer *scratch*, aparecerá nil en el área de eco, igual que cuando evalúas (buffer-file-name) en Info.

Por cierto, si estas en el búfer *scratch* y quieres que el valor devuelto por una expresión aparezca en el búfer en sí y no en el área de eco, presiona C-u C-x C-e en lugar de C-x C-e. Esto hace que el valor devuelto aparezca después de la expresión. El búfer se verá así:

(buffer-name)"*scratch*"

No se puede hacer esto en Info ya que Info es de solo lectura y no se permitirá cambiar el contenido del búfer. Pero puedes hacer esto en cualquier búfer que puedas editar; y cuando escribes código o documentación (como este libro), esta caracteristica es muy útil.

La función buffer-name devuelve el nombre del búfer; para obtener el búfer en sí, se necesita una función diferente: la función current-buffer. Si utilizas esta función en el código, lo que se obtiene es el búfer en sí.

Un nombre y el objeto o entidad al que se refiere el nombre son diferentes entre si. Tu no eres tu nombre, eres una persona a la que se refieren los demas por tu nombre. Si pides hablar con Jorge y alguien te entrega una tarjeta con las letras ‘J’, ‘o’, ‘r’, ‘g’, y ‘e’ escritas, podrias divertirte, pero no estarías satisfecho. No quieres hablar con el nombre, sino con la persona a la que se refiere el nombre. Un búfer es similar: el nombre del búfer scratch es *scratch*, pero el nombre no es el búfer. Para obtener un búfer en sí, es necesario utilizar una función como current-buffer.

Sin embargo, hay una ligera complicación: si evalúas current-buffer en una expresión por sí sola, como haremos aquí, lo que se ve es una representación impresa del nombre del búfer sin el contenido del búfer. Emacs funciona de esta forma por dos razones: el búfer puede contener miles de líneas––demasiado largo para mostrarse convenientemente; y, otro búfer puede tener el mismo contenido pero un nombre diferente, y es importante distinguir entre ellos.

Aquí hay una expresión que contiene la función:

(current-buffer)

Si evalúas esta expresión en Info de la manera habitual, aparecerá #<buffer *info*> en el área de eco. El formato especial indica que se está devuendo el búfer en sí, en lugar de solo su nombre.

Por cierto, si bien puedes escribir un número o símbolo en un programa, no se puede hacer esto con la representación impresa del búfer: la única manera de optener un búfer en sí mismo es con una función como current-buffer.

Una función relacionada es other-buffer. Esta devuelve el último bufer seleccionado distinto al que te encuentras actualmente, no una representación impresa de su nombre. Si recientemente has ido y vuelto del búfer *scratch*, other-buffer devolverá ese búfer.

Puedes ver esto evaluando la expresión:

(other-buffer)

Verás que #<buffer *scratch*> aparece en el área de eco, o el nombre de cualquier otro búfer al que allas cambiado anteriormente reciente⁵

La función other-buffer realmente proporciona un búfer cuando se utiliza como argumento de una función que requiera uno. Podemos ver esto usando other-buffer y switch-to-buffer para cambiar a un búfer diferente.

Pero primero, una breve introducción a la función switch-to-buffer. Cuando cambiaste de ida y vuelta de Info al búfer *scratch* para evaluar (buffer-name), probablemente pulsaste C-x b y luego escribiste *scratch*⁶ en el minibuffer cuando se solicito el nombre del buffer al que querias cambiar. El atajo, C-x b, hace que el intérprete Lisp evalúe la función interactiva switch-to-buffer. Como hemos dicho anteriormente, así es como funciona Emacs: diferentes atajos de teclado llaman o ejecutan diferentes funciones. Por ejemplo, C-f llama a forward-char, M-e llama a forward-sentence, etcétera.

Al escribir switch-to-buffer en una expresión, y darle un búfer al que cambiar, podemos cambiar de búfer tal y como lo hace C-x b.

(switch-to-buffer (other-buffer))

El símbolo switch-to-buffer es el primer elemento de la lista, por lo que el intérprete Lisp lo tratará como una función y llevara a cabo las instrucciones adjuntas al mismo. Pero antes de hacer esto, el intérprete observara que other-buffer está dentro de paréntesis y trabajara en este símbolo primero. other-buffer es el primer (y en este caso, el único) elemento de esta lista, por lo que el intérprete llama o ejecuta la función. Esto devuelve un búfer distinto al actual. A continuación, el intérprete ejecuta switch-to-buffer, pasando, como argumento, el búfer devuelto, que es al que Emacs cambiara. Si estás leyendo esto en Emacs, prueba ahora. Evalúa la expresión. (Para regresar, presiona C-x b RET.)⁷

En los ejemplos de las secciones siguentes, veras con más frecuencia la función set-buffer que switch-to-buffer. Esto se debe a la diferencia entre los programas de ordenador y los seres humanos: los humanos tienen ojos y esperan ver el búfer en el que están trabajando en la terminal de su ordenador. Esto es tan evidente, que casi no hace falta decirlo. Sin embargo, los programas no tienen ojos. Cuando un programa de ordenador trabaja en un búfer, el búfer no necesita ser visible en la pantalla.

switch-to-buffer está diseñado para humanos y hace dos cosas diferentes: cambia el búfer a el que Emacs dirige la atención; y cambia el búfer mostrado en la ventana al nuevo búfer. set-buffer, por otro lado, solo hace una cosa: cambia la atención del programa de ordenador a un búfer diferente. El búfer en la pantalla permanece sin cambios (por supuesto, normalmente no pasa nada hasta que el comando termina de ejecutarse).

Además, acabamos introduciendo otro termino tecnico, la palabra llamada. Cuando se evalúa una lista en la que el primer símbolo es una función, se llama a esa función. El uso del término viene de la noción de la función como una entidad que puede algo hacer por ti si la ‘llamas’––al igual que un fontanero es una entidad que puede arreglar una fuga si lo llamas.

Finalmente, veamos algunas funciones bastante simples, como buffer-size, point, point-min, y point-max. Estas proporcionan información sobre el tamaño de un búfer y la ubicación del punto dentro de el.

La función buffer-size te dice el tamaño del búfer actual; es decir, la función devuelve un conteo del número de caracteres en el buffer.

(buffer-size)

Puedes evaluar esto de la forma habitual, coloca el cursor después de la expresión y presiona C-x C-e.

En Emacs, la posición actual del cursor se llama punto. La expresión (point) devuelve un número que indica donde esta situado el cursor como un conteo del número de caracteres desde el principio del búfer hasta el punto.

Puedes ver el conteo de caracteres del punto para este búfer evaluando la siguiente expresión de la forma habitual:

(point)

Mientras escribo esto, el valor de point es 65724. La función point se utiliza con frecuencia en algunos de los ejemplos mas adelante en este libro.

El valor del punto depende, por supuesto, de su ubicacion dentro del búfer. Si evaluas el punto en este lugar, el número será mayor:

(point)

Para mí, el valor del punto en esta posición es 66043, lo que significa que hay 319 caracteres (incluyendo espacios) entre las dos expresiones. (Sin duda, verás números diferentes, ya que lo habré editado desde que evalue el punto por primera vez.)

La función point-min es similar a point, pero devuelve el valor mínimo permitido del punto en el búfer actual. Este es el numero 1 a menos que narrowing esté en efecto. (Narrowing (Reduccion) es un mecanismo mediante el cual puedes restringirte a ti mismo, o a un programa, a operar solo en un parte de un búfer. Consulta la Sección Reducir y Extender.) Del mismo modo, la función point-max devuelve el valor máximo permitido del punto en el búfer actual.

Busca un fichero en el que trabarjar y avanza hasta su mitad. Encuentra el nombre de búfer, el nombre del fichero, su tamaño, y la posición en el fichero.

Cuando el intérprete Lisp evalúa una lista, mira si el primer símbolo tiene una definición de funcion adjunta; o, dicho de otro modo, si el símbolo apunta a una definición de función. Si lo hace, el ordenador ejecuta las instrucciones de la definición. Un símbolo que tiene una definición de función se llamada, simplemente, una función (aunque hablando con propiedad, la definición es la función y el símbolo hace referencia a ella.)

Todas las funciones se defininen en términos de otras funciones, a excepción de algunas funciones primitivas que estan escritas en el lenguaje de programación C. Cuando escribas definiciones de funcion, debes escribirlas en Emacs Lisp y utilizar otras funciones como bloques de construcción. Algunas de las funciones que utilizaras estaran a su vez escritas en Emacs Lisp (quizás por tí) y otras serán primitivas escritas en C. Las funciones primitivas se usan exactamente igual que las escritas en Emacs Lisp y se comportan de igual forma. Están escritas en C para que podamos ejecutar facilmente GNU Emacs en cualquier ordenador que tenga la potencia suficiente y pueda ejecutar C.

Permíteme volver a enfatizar esto: cuando se escribe código en Emacs Lisp, no se distinge entre el uso de funciones escritas en C y el uso de funciones escritas en Emacs Lisp. La diferencia es irrevelante. Menciono la distinción solo porque es interesante conocerla. De hecho, a menos de que investigues, no sabras si una función ya escrita esta en Emacs Lisp o en C.

En Lisp, un símbolo como mark-whole-buffer tiene un código adjunto que le dice al ordenador que hacer cuando se invoca la función. Este código se denomina la definición de función y se crea evaluando una expresión Lisp que comienza con el símbolo defun (que es una abreviatura para define function (definir función)). Debido a que defun no evalúa sus argumentos de la manera habitual, se le llama una forma especial.

En las siguientes secciones, veremos algunas definiciones de función presentes dentro del código fuente de Emacs, como mark-whole-buffer. En esta sección, describiremos una definición de función sencilla para que puedas ver su aspecto. Esta definición de función usa aritmética porque es un ejemplo simple. A algunas personas les disgustan los ejemplos que usan aritmética; sin embargo, si eres una persona asi, no te desesperes. Casi ningun codigo a estudiar en el resto de esta introducción implica aritmética o matemáticas. Los ejemplos involucran principalmente texto de una forma u otra.

Una definición de función tiene hasta cinco partes despues de la palabra defun:

1. El nombre del símbolo al se debe vincular la definición de función.

2. Una lista de los argumentos que se pasan a la función. Si no hay argumentos que pasar a la función, tendremos una lista vacía, ().

3. Documentación que describe la función. (Técnicamente opcional, pero muy recomendable.)

4. Opcionalmente, una expresión para hacer que la función sea interactiva, de manera que se puede utilizarla presionando M-x seguido del nombre de la función; o pulsando una tecla o atajo de teclado.

5. El código que indica a el ordenador qué hacer: el cuerpo de la definición de función.

Es útil pensar que las cinco partes de una definición de función estan organizadas como en una plantilla, con ranuras para cada parte:

(defun nombre-de-función (argumentos…)
  "documentación-opcional…"
  (interactive informacion-de-paso-de-argumentos)     ; opcional
  cuerpo…)

A modo de ejemplo, aquí está el código de una función que multiplica su argumento por 7. (Este ejemplo no es interactivo. Consulta la Sección Crear una Función Interactiva, para obtener esa información.)

(defun multiplicar-por-siete (numero)
  "Multiplica NUMERO por siete."
  (* 7 numero))

Esta definición comienza con un paréntesis y el símbolo defun seguido por el nombre de la función.

El nombre de la función es seguido por una lista que contiene los argumentos que seran pasados a la función. Esta lista se llama lista de argumentos. En este ejemplo, la lista solo tiene un elemento, el símbolo numero. Cuando se utiliza la función, el símbolo sera asociado al valor que se utiliza como argumento de la función.

En lugar de elegir la palabra numero para el nombre del argumento, podría haber escogido cualquier otro nombre. Por ejemplo, la palabra multiplicando. Escogi la palabra ‘numero’ porque indica qué tipo de valor se pretende para este espacio; pero podría haber elegido ‘multiplicando’ para indicar el papel que jugara el valor en el funcionamiento de la función. Podría haberlo llamado foogle, pero habría sido una mala elección, ya que no comunicaria a los humanos qué significa. La elección del nombre es responsabilidad del programador y debe elegirse para hacer que el significado de la función quede claro.

De hecho, puedes elegir cualquier nombre que desees para un símbolo en una lista de argumentos, incluso el nombre de un símbolo utilizado en alguna otra función: el nombre que utilices en una lista de argumentos es privado para esa definición particular. En esta definición, el nombre hace referenecia a una entidad diferente a cualquiera que utilice el mismo nombre fuera de la definición de función. Supón que tu familia te apodan ‘Enano’; cuando tus familiares digan ‘Enano’, queren hacer referencia a ti. Pero fuera de tu familia, en una película, por ejemplo, el nombre ‘Enano’ se refiere a alguien más. Debido a que el nombre en una lista de argumentos es privado de la definición de la función, se puede cambiar el valor de un símbolo dentro del cuerpo de una función sin cambiar su valor fuera de la función. El efecto es similar al producido por la expresión let. (Consulta la sección let.)

La lista de argumentos es seguida por la cadena de documentación que describe la función. Esto es lo ves cuando presionas C-h f y escribes el nombre de una función. Por cierto, cuando escribas una cadena de documentación como esta, debes confeccionar la primera linea como una frace completa ya que algunos comandos, como apropos, solo imprimen la primer línea de una cadena de documentación de varias líneas. Ademas, no debes indentar la segunda línea de la cadena de documentación, si tienes una, porque se ve extraño al utilizar C-h f (describe-function). La cadena de documentación es opcional, pero es tan útil, que debería incluirse en casi cualquier función que escribas.

La tercer línea del ejemplo consiste en el cuerpo de la definición de función. (La mayoría de las definiciones de funcion, claro esta, son más extensas que esto.) En esta función, el cuerpo es la lista, (* 7 numero), que indica multiplicar el valor de numero por 7. (En Emacs Lisp, * es la función para multiplicar, al igual que + es la función para sumar.

Cuando se utiliza la función multiplicar-por-siete, el argumento numero se evalúa al número que desees usar. He aquí un ejemplo que muestra como utilizar multiplicar-por-siete; ¡pero no trates de evaluar esto primero!.

(multiplicar-por-siete 3)

El símbolo numero, especificado en la definición de función en la siguiente sección, se da o “une a” el valor 3 en el uso real de la función. Observa que aunque numero estaba dentro de paréntesis en la definición de función, el argumento pasado a la función multiplicar-por-siete no está entre paréntesis. Los paréntesis se escriben en la definición de función para que el ordenador pueda averiguar donde termina la lista de argumentos y donde inicia el resto de la definición de función.

Si evalúas este ejemplo, es probable que obtengas un mensaje de error. (¡adelante, intentalo!) Esto se debe a que hemos escrito la definición de función, pero aún no se ha comunicado al ordenador sobre la definición––aun no hemos instalado (o ‘cargado’) la definición de función en Emacs. Instalar una función es el proceso de comunicar al intérprete Lisp la definición de la función. La instalación se describe en la siguiente sección.

Si estás leyendo esto dentro en Emacs, puedes probar la función multiplicar-por-siete evaluando en primer lugar la definición de función y luego evaluando (multiplicar-por-siete 3). Hay una copia de la definición a continuación. Coloca el cursor después del último paréntesis de la definición de función y presiona C-x C-e. Al hacer esto, multiplicar-por-siete aparecerá en el área de eco. (Esto significa que cuando se evalua una definición de función, el valor devuelto es el nombre de la función definida.) Al mismo tiempo, esta acción instala la definición de función.

(defun multiplicar-por-siete (numero)
  "Multiplica NUMERO por siete."
  (* 7 numero))

Al evaluar este defun, estas instanlado multiplicar-por-siete en Emacs. La función ahora es una parte de Emacs tanto como forward-word o cualquier otra función de edición que utilices. (multiplicar-por-siete permanecera instalado hasta que salgas de Emacs. Para volver a cargar el código automáticamente cada vez que inicie Emacs, revisa la sección Instalar Código Permanentemente.)

Puedes ver el efecto de instalar multiplicar-por-siete evaluando el siguiente ejemplo. Coloca el cursor después de la siguiente expresión y presiona C-x C-e. El número 21 aparacerá en el área de eco.

(multiplicar-por-siete 3)

Si lo deseas, puedes leer la documentación de la función presiona C-h f (describe-function) y luego escribe el nombre de la función, multiplicar-por-siete. Al hacer esto, aparecerá una ventana *Help* en tu pantalla diciendo:

multiplicar-por-siete is a Lisp function.
(multiplicar-por-siete NUMERO)

Multiplica NUMERO por siete.

(Para volver a una sola ventana en tu pantalla, presiona C-x 1.)

Si quieres modificar el código de multiplicar-por-siete, simplemente reescribelo. Para instalar la nueva versión en lugar de la anterior, evalúa nuevamente la definición de la función. Esta, es la forma de modificar el código en Emacs. Es muy sencillo,

A modo de ejemplo, puedes cambiar la función multiplicar-por-siete para sumar el número a sí mismo siete veces en lugar de multiplicar el número por siete. Esto produce el mismo resultado, pero por una ruta diferente. Al mismo tiempo, añadiremos un comentario al codigo; un comentario es texto que el intérprete Lisp ignora, pero un lector humano puede encontrar útil o esclarecedor. El comentario es, que esta es la “segunda versión”.

(defun multiplicar-por-siete (numero)       ; Segunda versión.
  "Multiplica NUMERO por siete."
  (+ numero numero numero numero numero numero numero))

El comentario sigue a un punto y coma, ‘;’. En Lisp cualquier cosa en una línea despues de un punto y coma es un comentario. El fin de la línea es el fin del comentario. Para extender un comentario por dos o más líneas, inicia cada línea con un punto y coma.

Consulta las Secciónes Empieza por un fichero .emacs y Comentarios en El Manual de Referencia de GNU Emacs Lisp, para más informacion sobre los comentarios.

Puedes instalar esta versión de multiplicar-por-siete evaluándo esta del mismo modo en que evaluaste la primer función: coloca el cursor después del último paréntesis y presiona C-x C-e.

En resumen, asi es como puedes escribir código en Emacs Lisp: escribes una función; la instalas; la pruebas; luego haces correcciones o mejoras y la vuelves a instalar.

Puedes hacer a una función interactiva colocando una lista que inicia con la forma especial interactive inmediatamente después de la documentación. Un usuario puede invocar una función interactiva con M-x seguido del nombre de la función; o con un atajo de teclado ligado a esta, por ejemplo, presionando C-n para next-line o C-x h para mark-whole-buffer.

Cusionamente, cuando se llama a una función interactiva interactivamente, el valor devuelto no se muestra automáticamente en el área de eco. Esto se debe a que a menudo se llama a una función interactiva por sus efectos secundarios, como avanzar hacia adelante una palabra o una línea, y no por el valor devuelto. Si el valor devuelto se mostrara en el área de eco cada vez que presionas una tecla, seria muy molesto.

Tanto el uso de la forma especial interactive y la forma de mostrar un valor en el área de eco se pueden ilustrar creando una versión interactiva de multiplicar-por-siete.

Aquí está el código:

(defun multiplicar-por-siete (numero)       ; Versión Interactiva.
  "Multiplica NUMERO por siete."
  (interactive "p")
  (message "El resultado es %d" (* 7 numero)))

Para instalar este código, coloca el cursor después del ultimo parentesis y presiona C-x C-e. El nombre de la función aparecerá en el área de eco. A continuacion, puedes utilizar este código al presionar C-u segudo de un número, luego M-x multiplicar-por-siete y finalmente RET. En el área de eco aparecerá la frase ‘El resultado es …’ seguida por el producto.

Hablando en terminos mas generales, puedes invocar una función como ésta de dos maneras:

1. Escribiendo un argumento prefijo que contenga el número a pasar, y luego presionar M-x y el nombre de la función, como ocurre con C-u 3 M-x forward-sentence; o,

2. Pulsando cualquier tecla o atajo de teclado ligado a la función, como ocurre con C-u 3 M-e.

Ambos ejemplos operan de forma identica moviendo el punto hacia adelante tres oraciones. (Ya que multiply-by-seven no esta ligado a un atajo, no se puede utilizar como ejemplo.)

(Consulta la Seccion Algunos Atajos de teclado, para aprender como vincular un comando a una atajo.)

Un argumento prefijo se pasa a una función interactiva pulsando la tecla META seguida de un número, por ejemplo, M-3 M-e, o con C-u y luego un número, por ejemplo, C-u 3 M-e (si presionas C-u sin ningun número, el valor por defecto es 4).

Veamos es uso de la forma especial interactive y luego la función message en la versión interactiva de multiplicar-por-siete. Recordaras que la definición de función tiene el siguiente aspecto:

(defun multiplicar-por-siete (numero)       ; Versión Interactiva.
  "Multiplica NUMERO por siete."
  (interactive "p")
  (message "El resultado es %d" (* 7 numero)))

En esta función, la expresión, (interactive "p"), es una lista de dos elementos. La "p" le indica a Emacs que debe pasar el argumento prefijo a la función y utilizar este valor para el argumento de la función.

El argumento debe ser un número. Esto significa que el símbolo numero estara asociado a un número en la línea:

(message "El resultado es %d" (* 7 numero))

Por ejemplo, si tu argumento prefijo es 5, el intérprete Lisp evaluará la línea como si fuera:

(message "El resultado es %d" (* 7 5))

(Si estás leyendo esto en GNU Emacs, puedes evaluar esta expresión por ti mismo.) Primero, el intérprete evaluará la lista interna, que es (* 7 5). Esto devuelve un valor de 35. A continuación, se evaluará la lista externa, pasando los valores del segundo y posteriores elementos de la lista a la función message.

Como hemos visto, message es una función Emacs Lisp especialmente diseñada para enviar un mensaje de una línea al usuario. (Consulta la Seccion La función message.) En resumen, la función message imprime su primer argumento en el área de eco tal cual, excepto para las ocurrencias de ‘%d’, o ‘%s’ (y varias otras secuencias de control que no hemos mencionado). Cuando aparece una secuencia de control, la función busca el segundo argumento o los siguientes e imprime el valor del argumento en la ubicación donde se encuartra la secuencia de control.

En la función interactiva multiplicar-por-siete, la cadena de control es ‘%d’, que requiere un número, y el valor devuelto por la evaluación de (* 7 5) es el número 35. Por consiguiente, el número 35 se imprime en lugar de ‘%d’ y el mensaje es ‘El resultado es 35’.

(Observa que cuando llamas a la función multiplicar-por-siete, el mensaje se imprime sin comillas, pero cuando llamas a message, el texto se imprime entre comillas. Esto se debe a que el valor devuelto por message aparece en el área de eco cuando se evalúa una expresión cuyo primer elemento es message; pero si se integra en una función, message imprime el texto como un efecto secundario sin las comillas.)

En el ejemplo, multiplicar-por-siete utilizo "p" como el argumento para interactive. Este argumento le indica a Emacs que interpretara cualquer cosa que escribas despues de C-u o del comando META como un numero que sera el argumento a pasar a la funcion. Emacs tiene más de veinte caracteres predefinidos para usar con interactive. En casi todos los casos, una de estas opciones te permitira pasar la información correcta de forma interactiva a una función. (Consulta la Seccion Codigo de Caracteres para interactive en El Manual de Referencia de GNU Emacs Lisp).

Considera la función zap-to-char. Su expresión interactiva es

(interactive "p\ncZap to char: ")

La primer parte del argumento de interactive es ‘p’, con el que ya estás familiarizado. Este argumento le dice a Emacs que interprete un ‘prefijo’, como un número que se pasa a la función. Puedes especificar un prefijo presionando C-u seguido de un número o igualmente con META seguido por un número. El prefijo es un número de caracteres especifico. De este modo, si el prefijo es tres y el caracter especificado es ‘x’, entonces se borrará todo el texto hasta e incluido el tercer ‘x’ siguiente. Si no se establece un prefijo, entonces borras todo el texto hasta e incluido el carácter especificado, pero no más.

La ‘c’ le dice a la función el nombre del carácter que va a eliminar.

Más formalmente, una función con dos o más argumentos puede tener información que pasa a cada argumento añadiendo partes a la cadena que sigue a interactive. Al hacer esto, la información se pasa a cada argumento en el mismo orden que se especifica en la lista interactive. En la cadena, cada parte está separada de la siguente parte por un ‘\n’, que significa nueva línea. Por ejemplo, a ‘p’ puede continuar un ‘\n’ y un ‘cZap to char: ’. Esto hace que Emacs pase el valor del argumento prefijo (si lo hay) y el carácter.

En este caso, la definición de función se parece a la siguiente, donde arg y char son los símbolos que interactive vincula al argumento prefijo y el caracter especificado:

(defun nombre-de-funcion (arg char)
  "documentacion…"
  (interactive "p\ncZap to char: ")
  cuerpo-de-funcion…)

(El espacio después de los dos puntos en el prompt hace que se vea mejor. Consulta la Seccion La Definición de copy-to-buffer, para ver un ejemplo.)

Cuando una función no toma argumentos, interactive no requiere ninguno. Una función asi contiene unicamente la expresión (interactive). La función mark-whole-buffer es asi.

Alternativamente, si los códigos de letras especiales no son adecuados para tu aplicación, puedes pasar tus propios argumentos a interactive como una lista.

Consulta la Seccion La Definición de append-to-buffer, para ver un ejemplo. Consulta la Sección Usando interactive en El Manual de GNU Emacs Lisp, para una explicación más completa sobre esta técnica.

Cuando instalas una definición de función evaluandola, permanecera instalada hasta que salgas de Emacs. La proxima vez que inicies una nueva sesión de Emacs, la función no sera instalada a menos que evalúes de nuevo la definición.

En algún momento, podrias necesitar que el código se instale automáticamente cada vez que inicies una nueva sesión de Emacs. Hay varias formas de hacer esto:

• Si tienes código solo para tu personal, puedes poner el código de la definición de función en el fichero de inicialización .emacs. Cuando se inicia Emacs, el fichero .emacs se evalúa automáticamente y se instalan todas las definiciones de función que contiene. Consulta la Sección Tu Fichero .emacs.

• Como Alternativa, puedes poner las definiciones de función en uno o más ficheros y usar la función load para hacer que Emacs evalue y con ello instale cada una de las funciones en los ficheros. Consulta la Seccion Cargando ficheros.

• En Tercer lugar, si tienes código que todo tu sitio va a utilizar, es normal ponerlo en un fichero llamado site-init.el que se carga cuando se construye Emacs. Esto hace que el código este disponible para todos los usuarios de tu máquina. (Mira el fichero INSTALL que forma parte de la distribución Emacs.)

Finalmente, si tienes código que cualquier usuario de Emacs pueda querer, puedes publicarlo en una red de computadores o enviar una copia a la Free Software Foundation. (Al hacer esto, por favor licencia el código y su documentación bajo una licencia que permita a otras personas ejecutar, copiar, estudiar, modificar, y redistribuir el código y te proteja de quien tome tu trabajo.) Si envias una copia de tu código a la Free Software Foundation, y te proteges apropiadamente a ti mismo y a los demas, puede ser incluido en la siguiente version de Emacs. En gran parte, esta es la forma como ha crecido Emacs a través de los años, gracias a las de donaciones.

La expresión let es una forma especial de Lisp que tendras que utilizar en la mayoría de las definiciones de función.

let se utiliza para unir o enlazar un símbolo a un valor de tal manera que el intérprete no confunda la variable con otra variable del mismo nombre que no forme parte de la función.

Para entender por qué la forma especial let es necesaria, considera la situación donde eres dueño de una casa que generalmente vinculas con ‘la casa’, como en la frase, “La casa necesita pintura”. Si visitas a un amigo y tu anfitrion hace referencia a ‘la casa’, es probable que se refiera a su casa, no a la tuya, es decir, a una casa diferente.

Si tu amigo se refiere a su casa y tu crees que el se esta refiriendo a tu casa, puedes encontrarte en una situacion confusa. Lo mismo podría suceder en Lisp si una variable que se usa dentro de una función tiene el mismo nombre que una variable que se utiliza dentro de otra función, y no se pretende que ambas se refieran al mismo valor. La forma especial let permite evitar este tipo de confusión.

La forma especial let evita confusiones. let crea un nombre para una variable local que eclipsa cualquier uso del mismo nombre fuera de la expresión let. Esto es como entender que cuando tu anfitrion haga referencia a ‘la casa’, el quiere referirse a su casa, no la tuya. (Los símbolos usados en las listas de argumentos funcionan de la misma manera. Consulta la Sección La Forma Especial defun.)

Las variable locales creadas por una expresión let retienen su valor solo dentro de la expresión let (y dentro de las expresiones llamadas dentro de la expresión let); las variables locales no tiene efecto fuera de la expresión let.

Otra forma de persar sobre let es que es como un setq que es temporal y local. Los valores establecidos por let se deshacen automáticamente cuando let finaliza. La configuración solo afecta a las expresiones que se encuentran dentro de los limites de la expresión let. En la jerga informatica, diríamos que “la union de un simbolo solo es visible en las funciones llamadas en la forma let; en Emacs Lisp, el alcance es dinámico, no léxico.”

let puede crear más de una variable a la vez. Ademas, let da a cada variable que crea un valor inicial, ya sea un valor especificado por tí, o nil. (En la jerga, eso se llama ‘enlazar la variable al valor’.) Después de que let ha creado y enlazado las variables, ejecuta el código en el cuerpo del let y devuelve el valor de la última expresión en el cuerpo, como el valor de toda la expresión let. (‘Ejecutar’ es un término tecnico que significa evaluar una lista; proviene del significando de la palabra ‘llevar a la practica’ (Oxford English Dictionary). Puesto que se evalua una expresión para realizar una acción, ‘ejecutar’ ha evolucionado como un sinónimo para ‘evaluar’.)

Una expresión let es una lista de tres partes. La primer parte es el símbolo let. La segunda parte es una lista, llamada varlist (lista de variables), cada uno de cuyos elementos es un símbolo por sí mismo o una lista de dos elementos, cuyo primer elemento es un símbolo. La tercer parte de la expresión let es el cuerpo de let. El cuerpo normalmente consiste de una o más listas.

Una plantilla de la expresión let se veria asi:

(let varlist cuerpo…)

Los símbolos de la lista de varibles (varlist) son las variables a las que la forma especial let da valores de inicio. A los símbolos por si mismos se les da el valor inicial nil; y cada símbolo que sea el primer elemento de una lista de dos elementos se vincula al valor que se devuelve cuando el interprete Lisp evalúa el segundo elemento.

Por lo tanto, una varlist podria verse asi: (hilo (agujas 3)). En este caso, en una expresión let, Emacs une el símbolo hilo a un valor inicial de nil, y une el símbolo agujas a un valor inicial de 3.

Cuando escribes una expresión let, lo que haces es poner las expresiones apropiadas en los espacios de la plantilla de la expresión let.

Si la varlist está compuesta de listas de 2 elementos, como suele ser el caso, la plantilla de la expresión let se ve asi:

(let ((variable valor)
      (variable valor)
      …)
  cuerpo…)

La siguiente expresión crea y da valores iniciales a las dos variables cebra y tigre. El cuerpo de la expresión let es una lista que llama a la función message.

(let ((cebra 'rayas)
      (tigre 'fiero))
  (message "Un tipo de animal tiene %s y otro es %s."
           cebra tigre))

Aquí, la varlist es ((cebra 'rayas) (tigre 'fiero)).

Las dos variables son cebra y tigre. Cada variable es el primer elemento de una lista de dos elementos y cada valor es el segundo elemento de su lista de dos elementos. En la varlist, Emacs une la variable cebra al valor rayas⁸, y la variable tigre al valor fiero. En este ejemplo, ambos valores son símbolos precedidos por una cita. Los valores podrían muy bien haber sido otra lista o una cadena. El cuerpo de let sigue después de la lista que contiene las variables. En este ejemplo, el cuerpo es una lista que usa la función message para imprimir una cadena en el área de eco.

Puedes evaluar el ejemplo de la forma habitual, colocando el cursor después del último paréntesis y presionando C-x C-e. Al hacer esto, aparecerá lo siguiente en el área de eco:

"Un tipo de animal tiene rayas y otro es fiero."

Como hemos visto anteriormente, la función message imprime su primer argumento, excepto ‘%s’. En este ejemplo, el valor de la variable cebra se imprime en la ubicacion del primer ‘%s’ y el valor de la variable tigre se imprime en la ubicacion del segundo ‘%s’.

Si no se unen las variables en una sentencia let con valores de inicio específicos, automáticamente seran enlazados a un valor de inicio nil, como en la siguiente expresión:

(let ((abedul 3)
      pino
      abeto
      (roble 'algunos))
  (message "Aquí están %d variables con %s, %s, y el valor %s."
           abedul pino abeto roble))

Aquí, la varlist es ((abedul 3) pino abeto (roble 'algunos)).

Si evalúas esta expresión de la forma habitual, aparecerá lo siguiente en el área de eco:

"Aquí están 3 variables con nil, nil, y el valor algunos."

En este ejemplo, Emacs une el símbolo abedul al número 3, une los símbolos pino y abeto a nil, y el símbolo roble al valor algunos.

Observa que en la primer parte de let, las variables pino y abeto son unicamente átomos que no están rodeados por paréntesis; esto es porque estan siendo ligados a nil, la lista vacía. Pero roble su une a algunos por que es parte de la lista (roble 'algunos). De manera similar, abedul se une al número 3 en una lista con este número. (Ya que un número se evalúa a sí mismo, no es necesario citar el numero. Ademas, el número se imprime en el mensaje utilizando un ‘%d’ en lugar de un ‘%s’.) Las cuatro variables como grupo se ponen en una lista para delimitarlas del cuerpo de let.

Además de let y defun, esta la forma especial condicional if. Esta forma se utiliza para indicar al ordenador que tome decisiones. Puedes escribir definiciones de función sin necesidad de utilizar if, pero se usa con bastante frecuencia, y es lo suficientemente importante como para incluirla aquí. Se utiliza, por ejemplo, en el código de la función beginning-of-buffer.

La idea básica detras de if, es que “si (if) una prueba es verdadera entonces (then) se evalua la expresión”. Si la prueba no es verdadera, la expresión no se evalua. Por ejemplo, podrías tomar una decisión como, “si hace sol y calor, entonces ve a la playa!”

Al escribir una expresión if en Lisp no se utiliza la palabra ‘entonces’; la prueba y la acción son los elementos segundo y tercero de la lista cuyo primer elemento es if. No obstante, la parte de la prueba en una expresión if a menudo se llamada parte-si (if-part) y el segundo argumento a menudo se llamada parte-entonces (then-part).

Ademas, cuando se escribe una expresión if, la prueba-verdadero-o-falso normalmente se escribe en la misma línea que el símbolo if, pero la acción a llevar a cabo si la prueba es verdadera, “parte-entonces”, se escribe en la segunda y suguientes líneas. Esto hace que la expresión if sea mas fácil de leer.

(if prueba-verdadero-o-falso
    accion-a-realizar-si-la-prueba-es-verdadera)

La prueba-verdadero-o-falso es una expresión que evalua el intérprete Lisp.

Aquí hay un ejemplo que puedes evaluar. La prueba consiste en si el número 5 es mayor que el número 4. Puesto que es asi, se imprime el mensaje ‘¡5 es mayor que 4!’.

(if (> 5 4)                           ; parte-si
    (message "¡5 es mayor que 4!"))   ; parte-entonces

(La función > comprueba si su primer argumento es mayor que su segundo argumento y devuelve verdadero si lo es.)

Por supuesto, en un caso real, la prueba en una expresión if no será fija eternamente, como en la expresión (> 5 4). En su lugar, al menos una de las variables utilizadas en la prueba estara unida a un valor de antemano desconocido. (Si el valor se conociera de antemano, ¡no necesitariamos realizar la prueba!)

Por ejemplo, el valor puede estar unido a un argumento de una definición de función. En la siguiente definición de función, el tipo de animal es un valor que se pasa a la función. Si el valor unido a caracteristica es fiero, entonces se imprime el mensaje, ‘¡Es un tigre!’; de otro modo, se devolvera nil.

(defun tipo-de-animal (caracteristica)
  "Imprime el mensaje en el área de eco dependiendo de CARACTERISTICA.
Si la CARACTERISTICA es el símbolo ‘fiero’,
entonces advierte que es un tigre."
  (if (equal caracteristica 'fiero)
      (message "¡Es un tigre!")))

Si estás leyendo esto dentro de GNU Emacs, puedes evaluar la definición de función de la forma habitual para instalarla en Emacs, y luego puedes evaluar las siguientes dos expresiones para ver los resultados:

(tipo-de-animal 'fiero)

(tipo-de-animal 'cebra)

Al evaluar (tipo-de-animal 'fiero), veras el siguiente mensaje impreso en el área de eco: "¡Es un tigre!"; y cuando se evalúa (tipo-de-animal 'cebra) verás nil impreso en el área de eco.

Veamos en detalle la función tipo-de-animal.

La definición de función tipo-de-animal se escribio llenando los espacios de dos plantillas, una para la definición de función como un todo, y otra para una expresión if.

La plantilla para toda función no interactiva es:

(defun nombre-de-funcion (lista-de-argumentos)
  "documentacion…"
  cuerpo…)

Las partes de la función que coinciden con esta plantilla tienen el siguiente aspecto:

(defun tipo-de-animal (caracteristica)
  "Imprime el mensaje en el área de eco dependiendo de CARACTERISTICA.
Si la CARACTERISTICA es el símbolo ‘fiero’,
entonces advierte que es un tigre."
  cuerpo: la expresion if)

El nombre de función es tipo-de-animal; se le pasa el valor de un argumento. A la lista de argumentos le sigue una cadena de documentación multilínea. La cadena de documentación se incluiye en el ejemplo porque es un buen hábito escribir un cadena de documentación para cada definición de función. El cuerpo de la definición de función consiste en la expresión if.

La plantilla de una expresión if se ve así:

(if prueba-verdadero-o-falso
    accion-a-realizar-si-la-prueba-devuelve-verdadero)

En la función tipo-de-animal, el código para el if se ve así:

(if (equal caracteristica 'fiero)
    (message "¡Es un tigre!")))

Aquí, está la expresión prueba-verdadero-o-falso

(equal caracteristica 'fiero)

En Lisp, equal es una función que determina si su primer argumento es igual al segundo. El segundo argumento es el símbolo citado 'fiero y el primer argumento es el valor del símbolo característica––en otras palabras, el argumento pasado a esta función.

En la primer prueba de tipo-de-animal, el argumento fiero se pasa a tipo-de-animal. Ya que fiero es igual a fiero, la expresión, (equal caracteristica 'fiero), devuelve el valor verdadero. Cuando esto sucede, if evalúa el segundo argumento o la parte-entonces del if: (message "¡Es un tigre!").

Por otro lado, en la segunda prueba de tipo-de-animal, se pasa el argumento cebra a tipo-de-animal. cebra no es igual a fiero, por lo que la parte-entonces no se evalua y la expresión if devuelve nil).

Una expresión if puede tener un tercer argumento opcional, llamado parte-de-otro-modo (else-part), en caso de que la prueba-verdadero-o-falso devuelva falso. Cuando esto sucede, el segundo argumento o parte-entonces de la expresión if global no se evalúa, pero el tercer argumento o parte-de-otro-modo se evalúa. Podrías pensar en esto como la alternativa del día nublado para la decisión “si es cálido y soleado, entonces ir a la playa!, de otro modo leer un libro!”

La palabra “else” (de otro modo) no se escribe en el código Lisp; la parte-de-otro-modo de una expresión if viene después de la parte-entonces. En Lisp, la parte-de-otro-modo suele escribirse al inicio de una nueva linea y tiene menos indentacion que la parte-entonces:

(if prueba-verdadero-o-falso
    accion-a-realizar-si-la-prueba-devuelve-verdadero
  accion-a-realizar-si-la-prueba-devuelve-falso)

Por ejemplo, evaluar la siguiente expresión if imprime el mensaje ‘¡4 no es mayor que 5!’:

(if (> 4 5)                                   ; parte-if
    (message "¡4 falsamente es mayor que 5!") ; parte-then
  (message "¡4 no es mayor que 5!"))          ; parte-else

Observa que los diferentes niveles de indentación hacen fácil distinguir la parte-entonces (por brevedad, y mezclando ingles con español, apartir de ahora (parte-then)) de la parte-de-otro-modo (por brevedad, y mezclando ingles con español, apartir de ahora (parte-else)). (GNU Emacs tiene varios comandos que indentan expresiones if automáticamente. Consulta la Seccion GNU Emacs te ayuda a escribir listas.)

Podemos ampliar la función tipo-de-animal para incluir una parte-else simplemente incorporando una parte adicional a la expresión if.

Puedes ver las consecuencias de hacer esto si evalúas la siguiente versión de la función tipo-de-animal y luego evaluas las dos expresiones siguientes que pasan argumentos diferentes a la función.

(defun tipo-de-animal (caracteristica)
  "Imprime un mensaje en el área de eco dependiendo de la CARACTERISTICA.
Si la CARACTERISTICA es el símbolo ‘fiero’,
entonces advierte que es un tigre.
de otro modo dice que no es fiero"
  (if (equal caracteristica 'fiero)
      (message "¡Es un tigre!")
    (message "!No es feroz!")))

(tipo-de-animal 'fiero)

(tipo-de-animal 'cebra)

Cuando evalues (tipo-de-animal 'fiero), verás el siguiente mensaje en el área de eco: "¡Es un tigre!"; cuando evalues (tipo-de-animal 'cebra), verás "¡No es feroz!".

(Por supuesto, si característica fuera muy-feroz, se imprimiria el mensaje "¡No es feroz!"; ¡y sería un error! Cuando escribas código, debes tener en cuenta la posibilidad de que algun argumento como este sea probado por if y acorde a ello escribir tu programa.

Hay un aspecto importante para probar la verdad en una expresión if. Hasta ahora, hemos hablado de ‘verdadero’ y ‘falso’ como valores de predicados como si fueran nuevos tipos de objetos Emacs Lisp. De hecho, solo nuestro viejo amigo nil es ‘falso’. Cualquier otra cosa––cualquiera en absoluto––es ‘verdadero’.

La expresión que prueba si algo es verdadero se interpreta como true (verdadero) si el resultado de la evaluacion es no nil. En otras palabras, el resultado de la prueba se considera verdadero si el valor devuelto es un número como 47, una cadena como "hola", o un símbolo (distinto de nil) como flores, o una lista (siempre y cuando no este vacía) o incluso ¡un búfer!

Antes de ilustrar una prueba para verdadero, necesitamos una explicación de nil.

En Emacs Lisp, el símbolo nil tiene dos significados. En primer lugar, significa que la lista está vacía. En segundo lugar, significa falso y es el valor devuelto cuando una prueba-verdadero-o-falso obtiene falso. nil puede escribirse como una lista vacia, (), o como nil. En lo referente al interprete Lisp () y nil son lo mismo. Los humanos, sin embargo, tienden a usar nil para falso y () para lista vacía.

En Emacs Lisp, cualquier valor que no sea nil––si no es una lista vacía––se considera verdadero. Esto significa que si una evaluación devuelve algo que no es una lista vacía, una expresión if probara ser verdadera. Por ejemplo, si un número se coloca en el lugar de la prueba, se evaluara y devolverá su valor, ya que eso es lo que hacen los números cuando se evalúan. En esta condicion, la expresión if pasara su prueba como verdadero. La expresión pasara su prueba como falsa solo cuando nil, o una lista vacía, son devueltas al evaluar la expresión.

Puedes ver esto evaluando las dos expresiones en los ejemplos siguientes.

En el primer ejemplo, el número 4 se evalua como la prueba en la expresión if y se devuelve a si mismo; en consecuencia, se evalua y devuelve la parte-then de la expresión: aparece ‘verdadero’ en el área de eco. En el segundo ejemplo, nil indica falso; en consecuencia, se evalua y devuelve la parte-else de la expresión: aparece ‘falso’ en el área de eco.

(if 4
    'verdadero
  'falso)

(if nil
    'verdadero
  'falso)

Por cierto, si algún otro valor de utilidad no está disponible para una prueba que devuelve verdadero, entonces el intérprete Lisp devolvera el símbolo t para verdadero. Por ejemplo, la expresión (> 5 4) devuelve t cuando se evalúa, como puedes comprobar si evaluas:

(> 5 4)

Por otra parte, esta función devuelve nil si la prueba es falsa.

(> 4 5)

La función save-excursion es la cuarta y última forma especial que discutiremos en este capítulo.

En los programas Emacs Lisp utilizados para la edición, la función save-excursion es muy común. Guarda la posición del punto y marca, ejecuta el cuerpo de la función, y luego restaura el punto y marca a sus posiciones previas si sus posiciones fueron cambiadas. Su proposito principal es impedir que el usuario se sorprenda y perturbe por el movimiento inesperado del punto o marca.

Sin embargo, antes de hablar de save-excursion, puede ser útil examinar primero que son el punto y la marca en GNU Emacs. Punto es la posición actual del cursor. Donde sea que se encuentre el cursor, estara el punto. De forma más precisa, en los terminales donde el cursor aparece sobre un carácter, el punto se encuentra inmediatamente antes del carácter. En Emacs Lisp, el punto es un numero entero. El primer carácter en un búfer es el número uno, el segundo es el número dos, y así sucesivamente. La función point devuelve la posición actual del cursor como un número. Cada búfer tiene su propio valor para el punto.

La marca es otra posición en el búfer; su valor se puede establecer con un comando como C-SPC (set-mark-command). Si se ha establecido una marca, puedes utilizar el comando C-x C-x (exchange-point-and-mark) para hacer que el cursor salte a la marca y establecer la marca como la posición anterior del punto. Además, si se establece otra marca, la posición de la marca anterior se guarda en el anillo de marcas. Muchas posiciones de marca se pueden guardar de esta manera. Se puede mover el cursor a una marca guardada presionando C-u C-SPC una o más veces.

La parte del búfer entre el punto y la marca se denomina la región. Numerosos comandos trabajan en la región, incluyendo center-region, count-lines-region, kill-region y print-region.

La forma especial save-excursion guarda las ubicaciones del punto y la marca y restaura estas posiciones después de que el interprete Lisp evalua el código dentro del cuerpo de la forma especial. De este modo, si el punto se encontraba al inicio de un texto y algún código moviera el punto al final del búfer, save-excursion volvera a poner el punto donde estaba antes, luego que las expresiones en el cuerpo de la funcion fueran evaluadas.

En Emacs, una función se mueve con frecuencia de punto a otro como parte de su funcionamiento interno, aunque el usuario no lo espere. Por ejemplo, count-lines-region mueve el punto. Para evitar que el usuario sea molestado por saltos inesperados y (desde el punto de vista del usuario) innecesarios, save-excursion se utiliza a menudo para conservar el punto y la marca en la posición esperada por el usuario. El uso de save-excursion es bueno para mantener el orden.

Para asegurarse que la casa se mantiene limpia, save-excursion restaura los valores del punto y la marca incluso si algo va mal con el código en su cuerpo (o, para ser más preciso y usar el lenguaje tecnico apropiado, “en caso de salida anormal”). Esta caracteristica es muy útil.

Además de registrar los valores del punto y marca, save-excursion mantiene un registro del buffer actual, y tambien lo restaura. Esto significa que puedes escribir código que cambie de bufer y save-excursion lo devuelva al bufer original. Asi es como se utiliza save-excursion en append-to-buffer. (Consulta la Seccion La Definición de append-to-buffer.)

La plantilla de código usando save-excursion es simple:

(save-excursion
  cuerpo…)

El cuerpo de la función es una o más expresiones que serán evaluadas de forma secuencial por el intérprete Lisp. Si hay más de una expresión en el cuerpo, el valor de la última será devuelto como el valor de la función save-excursion. Las otras expresiones en el cuerpo solo se evaluan por sus efectos secundarios; y save-excursion en misma solo se utiliza por su efecto secundario (que es restaurar las posiciones del punto y la marca).

La siguiente plantilla explica save-excursion, con más detalle:

(save-excursion
  primera-expresion-en-el-cuerpo
  segunda-expresion-en-el-cuerpo
  tercera-expresion-en-el-cuerpo
   …
  ultima-expresion-en-el-cuerpo)

Una expresión, por supuesto, puede ser un símbolo por sí mismo o una lista.

En el código Emacs Lisp, una expresión save-excursion a menudo ocurre dentro del cuerpo de una expresión let. Tiene un aspecto algo asi:

(let varlist
  (save-excursion
    cuerpo…))

En los últimos capítulos se han introducido un buen número de funciones y formas especiales. A continuacion se describen brevemente, junto con algunas funciones similares que aun no se han mencionado.

eval-last-sexp

Evalúa la última expresión simbólica antes de la posición actual del punto. El valor se imprime en el área de eco a menos que la función se invoque con un argumento; en este caso, la salida se imprime en el búfer actual. Este comando normalmente esta ligado a C-x C-e.

defun

Define una función. Esta forma especial consta de hasta cinco partes: el nombre, una plantilla para los argumentos que se pasan a la función, la documentacion, una declaración interactiva opcional, y el cuerpo de la definición.

Por ejemplo, en las primeras versiones de Emacs, la definición de la función back-to-indentation era la siguiente. (Es ligeramente más compleja ahora que busca el primer caracter que no es espacio en lugar del primer caracter visible.)

(defun back-to-indentation ()
  "Mueve el punto al primer caracter visible de la linea."
  (interactive)
  (beginning-of-line 1)
  (skip-chars-forward " \t"))

interactive

Anuncia al intérprete que la función se puede usar de forma interactiva. Esta forma especial puede ir seguida de una cadena con una o más partes que pasan la información a los argumentos de la función, de forma secuencial. Estas partes pueden también decir al intérprete que solicite información. Las partes de la cadena estan separadas por saltos de linea, ‘\n’.

Los codigos de caractere comúnes son:

• b: El nombre de un búfer existente.

• f: El nombre de un fichero existente

• p: El argumento prefijo numérico. (Observa que esta ‘p’ es minúscula.)

• r: El punto y la marca, como dos argumentos numéricos, el más pequeño primero. Este es el unico codigo de una letra que especifica dos argumentos sucesivos en lugar de uno.

Consulta la Seccion Codigo de caracteres para ‘interactive’ en El Manual de Referencia de GNU Emacs Lisp, para obtener una lista completa de los codigos de caracteres.

let

Declara una lista de variables para utilizarla dentro del cuerpo de let y darle a cada variable un valor inicial, ya sea nil o un valor específicado; luego evalua el resto de las expresiones en el cuerpo del let y devuelve el valor de la última expresion. Dentro del cuerpo del let, el intérprete Lisp no ve los valores de las variables con el mismo nombre declaradas fuera de let.

Por ejemplo,

(let ((foo (buffer-name))
      (bar (buffer-size)))
  (message "Este buffer es %s y tiene %d caracteres."
           foo bar))

save-excursion

Registra los valores de punto, marca y del búfer actual antes de evaluar el cuerpo de esta forma especial. Tras evaluar su cuerpo, restaura los valores de punto, marca y búfer.

Por ejemplo,

(message "Estamos %d caracteres dentro de este buffer."
         (- (point)
            (save-excursion
              (goto-char (point-min))
              (point))))

if

Evalúa el primer argumento de la función; si es verdadero, evalúa el segundo argumento; de otra forma evalúa el tercer argumento, si lo hay.

La forma especial if se llamada condicional. Hay otros condicionales en Emacs Lisp, pero if es quizás el más utilizado.

Por ejemplo,

(if (= 24 emacs-major-version)
    (message "Esta es la version 24 de Emacs")
  (message "Esta no es la version 24 de Emacs"))

<, >, <=, >=

La función < prueba si su primer argumento es menor que el segundo. >, prueba si el primer argumento es mayor que el segundo. Del mismo modo, <= prueba si el primer argumento es menor o igual al segundo y >= si el primer argumento es mayor o igual al segundo. En todos los casos, ambos argumentos deben ser números o marcadores (los marcadores indican posiciones en búfers).

=

La función = prueba si dos argumentos, ambos números o marcadores, son iguales.

equal, eq

Prueban si dos objetos son el mismo. equal utiliza un signicado de la palabra ‘mismo’ y eq utiliza otro: equal devuelve verdadero si los dos objetos tienen una estructura y contenidos similares, por ejemplo, dos copias del mismo libro. Por otro lado, eq, devuelve verdadero si ambos argumentos son realmente el mismo objeto.

string<, string-lessp, string=, string-equal

La función string-lessp prueba si su primer argumento es menor que el segundo. Un nombre alternativo mas corto para la misma función (un defalias) es string<.

Los argumentos para string-lessp deben ser cadenas o símbolos; la ordenación es lexicográfica, por lo que mayusculas o minusculas son significativas. Los nombres impresos de símbolos se utilizan en lugar de los símbolos mismos.

Una cadena vacía, ‘""’, una cadena sin caracteres, es más pequeña que cualquier cadena de caracteres.

string-equal proporciona la prueba correpondiente para la igualdad. Su nombre alternativo es string=. No hay funciones de prueba de cadenas que correspondan a >, >= o <=.

message

Imprime un mensaje en el área de eco. El primer argumento es una cadena que puede contener, ‘%s’, ‘%d’, o ‘%c’ para imprimir el valor de los argumentos que siguen a la cadena. El argumento utilizado por ‘%s’ debe ser una cadena o un simbolo, el argumeto utilizado por ‘%d’ debe ser un número. El argumento usado por ‘%c’ debe ser un codigo númerico ASCII; se imprimira como el caracter con ese código ASCII. (No se han mencionado otras secuencias porcentuales %-).

setq, set

La función setq asigna al valor de su primer argumento el valor del segundo argumento. El primer argumento se cita automáticamente por setq. Hace lo mismo para los pares sucesisvos de argumentos. La función, set, toma solo dos argumentos y evalúa ambos antes de asignar el valor devuelto por su primer argumento al valor devuelto por el segundo argumento.

buffer-name

Sin un argumento, devuelve el nombre del búfer, como una cadena.

buffer-file-name

Sin un argumento, devuelve el nombre del fichero del búfer que se esta visitando.

current-buffer

Devuelve el búfer en el que Emacs se encuentra activo; Puede que no sea el búfer que es visible en la pantalla.

other-buffer

Devuelve el ultimo búfer seleccionado mas recientemente (distinto del buffer pasado a other-buffer como un argumento y distinto del búfer actual).

switch-to-buffer

Selecciona un búfer de Emacs para activarlo y mostralo en la ventana actual para que los usuarios puedan verlo. Normalmente ligado a C-x b.

set-buffer

Cambiar la atención de Emacs a un búfer en el que se ejecutaran los programas. No altera lo que muestra la ventana.

buffer-size

Devuelve el número de caracteres en el búfer actual.

point

Devuelve el valor de la posicion actual del cursor, como un entero contando el número de caracteres desde el inicio del búfer.

point-min

Devuelve el valor mínimo admisible del punto en el búfer actual. Esto es 1, a menos que narrowing esté activo

point-max

Devuelve el valor máximo admisible del punto en el búfer actual. Este es el fin del búfer, a menos que narrowing este activo.

• Escribe una función no interactiva que duplique el valor de su argumento, un número. Luego haz la función interactiva.

• Escribe una función que compruebe si el valor actual de fill-column es mayor que el argumento pasado a la función, y si es así, imprime un mensaje apropiado.

En este capítulo estudiamos en detalle varias de las funciones usadas en GNU Emacs. Esto se denomina “walk-through” (recorrido) (visita o demostracion de un area o tarea). Estas funciones se utilizan como ejemplos de código Lisp, pero no son ejemplos imaginarios; con excepción del primero, con la definición de función simplificada, estas funciones muestran el código real usado en GNU Emacs. Se puede aprender mucho de estas definiciones. Las funciones aquí descritas están relacionadas a los búfers. Mas tarde, estudiaremos otras funciones.

En este recorrido, describire cada nueva función a medida que lleguemos a ella, a veces en detalle y a veces brevemente. Si estás interesado, puedes obtener la documentación completa de cualquier función de Emacs Lisp en cualquier momento presionando C-h f y luego ingresando el nombre de la función (y luego RET). Del mismo modo, se puede obtener la documentación completa de una variable con C-h v, luego el nombre de la variable (y despues RET).

Ademas, describe-function te dira la ubicacion de la definición de la función.

Coloca el punto sobre el nombre del fichero que contiene la función y presiona la tecla RET. En este caso, RET significa push-button en lugar de ‘return’ o ‘enter’. Emacs te llevara directamente a la definición de la función.

De manera más general, si quieres ver una función en su fichero fuente original, puedes utilizar la función find-tag para saltar a la misma. find-tag trabaja con una amplia variedad de lenguajes, no solo Lisp, y C, y tambien funciona con texto en general. Por ejemplo, find-tag saltará a los distintos nodos del codigo fuente de este documento. La función find-tag depende de ‘tablas de etiquetas’ que registran las ubicaciones de las funciones, variables, y otros elementos a los que find-tag salta.

Para usar el comando find-tag, presiona M-. (es decir, presiona la tecla punto mientras presionas la tecla META, o presiona ESC y luego la tecla punto), a continuacion, en el prompt, escribe el nombre de la función para ver su código fuente, por ejemplo mark-whole-buffer, y luego pulsa RET. Emacs cambiará de búfer y mostrará el código fuente de la función en la pantalla. Para regresar a tu búfer actual, presiona C-x b RET. (En algunos teclados, la tecla META se etiqueta como ALT.)

Dependiendo de la configuracion de los valores iniciales predeterminados de tu copia de Emacs, puede ser necesario especificar la posición de tu ‘tabla de etiquetas’, que es un fichero llamado TAGS. Por ejemplo, si estás interesado en el codigo fuente de Emacs, lo mas probable es que la tabla de etiquetas que deseas, si ya ha sido creada, este en un subdirectorio del directorio /usr/local/share/emacs; de este modo se usaría el comando M-x visit-tags-table y se especificaria una ruta como /usr/local/share/emacs/24.1.1/lisp/TAGS. Si la tabla de etiquetas no ha sido creada, tendrás que crearla por tí mismo. Estara en un fichero como /usr/local/src/emacs/src/TAGS.

Para crear un fichero TAGS en un directorio específico, cambia a ese directorio en Emacs utilizando el comando M-x cd, o lista el directorio con C-x d (dired). A continuacion ejecuta el comando compile, con etags *.el asi:

M-x compile RET etags *.el RET

Para más información, consulta la Seccion Crea tu propio fichero TAGS.

Después de que te familiarices con Emacs Lisp, encontrarás que utilizas con frecuencia find-tag como metodo para navegar por el código fuente; y crearás tus propias tablas TAGS.

Por cierto, los ficheros que contienen código Lisp se denominan convencionalmente librerías. La metáfora se deriva que una librería especializada, como una librería de leyes o una librería de ingeniería, en lugar de una librería general. Cada librería, o fichero, contiene funciones que se relacionan con un tema o actividad particular, por ejemplo abbrev.el para manejar abreviaturas y atajos, y help.el para la ayuda en linea. (Algunas veces varias librerías proporcionan código para una sola actividad, como los distintos ficheros rmail… que proporcionan codigo para leer correo electrónico.) En El Manual de GNU Emacs, verás frases como “El comando C-h p te permite buscar las librerias estándar de Emacs Lisp por palabras clave del tema.”

El comando beginning-of-buffer es una buena función para empezar, ya que es probable que estes familiarizado con ella y es fácil de entender. Utilizado como un comando interactivo, beginning-of-buffer mueve el cursor al inicio del búfer, dejando la marca en la posición anterior. Esta generalmente ligado a M-<.

En esta sección, discutiremos una versión reducida de la función que muestra como se utiliza con mayor frecuencia. Esta función reducida funciona como esta escrita, pero no contiene código para una opcion compleja. En otra sección, describiremos la función completa. (Consulta la Seccion Definición completa de beginning-of-buffer.

Antes de mirar el código, consideremos lo que debe contener la definición de función: debe incluir una expresión que haga que la función sea interactiva para que puede llamarse tecleando M-x beginning-of-buffer o pulsando algun atajo como M-<; debe incluir código para dejar una marca en la posición original del búfer; y debe incluir código para mover el cursor al inicio del búfer.

Aquí está el texto completo la versión reducida de la función:

(defun beginning-of-buffer-simplificado ()
  "Mueve el punto al inicio del buffer;
deja la marca en la posicion anterior."
  (interactive)
  (push-mark)
  (goto-char (point-min)))

Como todas las definiciones de función, esta definición tiene cinco partes que siguen la forma especial defun:

1. El nombre: en este ejemplo, beginning-of-buffer-simplificado.

2. Una lista de argumentos: en este ejemplo, una lista vacía, (),

3. La cadena de documentación.

4. La expresión interactiva.

5. El cuerpo.

En esta definición de función, la lista de argumentos está vacía; esto significa que esta función no requiere ningun argumento. (Cuando veamos la definición de la función completa, veremos que se puede pasar un argumento opcional.)

La expresión interactiva le indica a Emacs que se pretende utilizar la función de forma interactiva. En este ejemplo, interactive no tiene un argumento porque beginning-of-buffer-simplificado no lo requiere.

El cuerpo de la función esta formado por dos líneas:

(push-mark)
(goto-char (point-min))

La primera de estas líneas es la expresión, (push-mark). Cuando el interprete Lisp evalua esta expresión, pone una marca en la posición actual del cursor, donde sea que este. La posición de esta marca se guarda en el anillo de marcas.

La siguiente línea es (goto-char (point-min)). Esta expresión hace saltar el cursor hasta el punto mínimo en el búfer, es decir, al inicio del búfer (o al inicio de la porción accesible del búfer si narrowed esta activo. Consulta la Seccion Reducir y Extender.)

El comando push-mark establece una marca en el sitio donde se encontraba el cursor antes de que la expresión (goto-char (point-min)) lo moviera al principio del bufer. En consecuencia, puedes, si quieres, volver a donde estabas originalmente presionando C-x C-x.

¡Esto es todo lo que hay en la definición de función!

Cuando leas código como este y te encuentres con una función desconocida, como goto-char, puedes averiguar que es lo que hace mediante el comando describe-function. Para usar este comando, presiona C-h f, luego escribe el nombre de la función y presiona RET. El comando describe-function imprimirá la cadena de documentacion de la función en una ventana *Help*. Por ejemplo, la documentación de goto-char es:

Establece el punto a POSICION, un numero o marcador.
El inicio del buffer es la posicion (point-min), el final es (point-max).

El argumento de la función es la posición deseada.

(En el caso de describe-function el prompt te facilita el símbolo adelante o debaje del cursor, lo que te puede evitar escribir el nombre de la funcion al colocar el cursor encima o después de la función y luego presionar C-h f RET.)

La definición de la función end-of-buffer se escribe de la misma forma que la definición beginnig-of-buffer excepto que el cuerpo de la función contiene la expresión (goto-char (point-max)) en lugar de (goto-char (point-min))

La función mark-whole-buffer no es mas difícil de entender que la función beginning-of-buffer-simplificado. En este caso, sin embargo, veremos la función completa, no una versión reducida.

La función mark-whole-buffer no se utiliza con tanta frecuencia como la función beginning-of-buffer, pero no es menos útil: marca un búfer completo como una región colocando el punto al inicio y una marca al final del búfer. Generalmente se enlaza a C-x h.

En GNU Emacs 22, el código de la función completa se ve asi:

(defun mark-whole-buffer ()
  "Coloca el punto al inicio y la marca el final del buffer.
Probablemente no deberias utilizar esta funcion en programas Lisp;
Por lo general es un error que una funcion Lisp utilice cualquier subrutina
que utilice o establesca la marca."
  (interactive)
  (push-mark (point))
  (push-mark (point-max) nil t)
  (goto-char (point-min)))

Al igual que todas las demas funciones, la función mark-whole-buffer encaja dentro de la plantilla de una definición de funcion. La plantilla luce asi:

(defun nombre-de-funcion (lista-de-argumentos)
  "documentacion…"
  (expresion-interactiva…)
  cuerpo…)

Asi es cómo funciona la función: el nombre de la función es mark-whole-buffer; le sigue una lista de argumentos vacía, ‘()’, lo que significa que la función no requiere argumentos. La documentación viene despues.

La siguiente línea es una expresión (interactive) que indica a Emacs que la función se utilizara de forma interactiva. Estos detalles son similares a la función beginning-of-buffer-simplificado descrita en la sección anterior

El cuerpo de la función mark-whole-buffer consiste en tres líneas de código:

(push-mark (point))
(push-mark (point-max) nil t)
(goto-char (point-min))

La primera de estas líneas es la expresión, (push-mark (point)).

Esta línea hace exactamente el mismo trabajo que la primera línea del cuerpo de la función beginning-of-buffer-simplificado, en la que solo se escribe (push-mark). En ambos casos, el intérprete Lisp coloca una marca en la posición actual del cursor.

No sé por qué en la expresión mark-whole-buffer se escribe (push-mark (point)) y en la expresión beginning-of-buffer se escribe (push-mark). Quizás quien escribió el código no conocia que los argumentos de push-mark son opcionales y que si no se pasa un argumento a push-mark, la función establece automáticamente la marca en la posicion del punto por defecto. O quizás la expresión fué escrita de manera que fuera paralela a la estructura de la siguiente línea. En cualquier caso, la línea hace que Emacs determine la posición del punto y coloque una marca allí.

En versiones anteriores de GNU Emacs, la siguiente línea de mark-whole-buffer era (push-mark (point-max)). Esta expresión establece una marca en el punto del búfer que tiene el número más alto. Este será el final del búfer (o, si el búfer tiene activo narrowing, el final de la porción accesible del búfer. Consulta la Seccion Reducir y Extender, para más informacion sobre norrowing). Después de colocar esta marca, la marca anterior, la establecida en el punto, ya no esta establecida, pero Emacs recuerda su posición, al igual que todas las otras marcas recientes. Esto significa que, si lo deseas, puedes volver a esta posición presionando C-u C-SPC dos veces.

En GNU Emacs 22, (point-max) es ligeramente más complicado. La línea es

(push-mark (point-max) nil t)

La expresión funciona casi igual que antes. Establece una marca en la posicion con el numero mas alto posible en el búfer. Sin embargo, en esta versión, push-mark tiene dos argumentos adicionales. El segundo argumento de push-mark es nil. Esto le indica a la función que debe mostrar un mensaje que diga ‘Mark set’ cuando se coloca la marca. El tercer argumento es t. Esto le indica a push-mark que active la marca cuando el modo Transient Mark está activo. El modo Transient Mark resalta la región activa. Con frecuencia esta desactivado.

Finalmente, la última línea de la función es (goto-char (point-min))). Se escribe exactamente de la misma forma como se escribio beginning-of-buffer. La expresión mueve el cursor al punto mínimo en el búfer, es decir, al inicio del búferr (o al inicio de la porción accesible del búfer). Como resultado de esto, el punto se coloca al inicio del búfer y la marca se encuentra al final del búfer. Por tanto, la región es todo el búfer.

El comando append-to-buffer es más complejo que el comando mark-whole-buffer. Lo que hace es copiar la región (es decir, la parte del búfer entre el punto y la marca) del buffer actual a un búfer específico.

El comando append-to-buffer utiliza la función insert-buffer-substring para copiar la región. insert-buffer-substring se describe por su nombre: toma una cadena de caracteres de una parte de un búfer, una “subcadena”, y la inserta en otro búfer.

La mayor parte de append-to-buffer tiene que ver con establecer las condiciones para que insert-buffer-substring funcione: el código debe especificar tanto el búfer al que ira el texto, la ventana de la que viene y a la que va, como la región que será copiada.

Aquí está el texto completo de la función:

(defun append-to-buffer (buffer start end)
  "Añade al buffer especificado el texto de la region.
Este se inserta en ese buffer antes de su punto.

Cuando se llama desde un programa, se pasan tres argumentes:
BUFFER (o nombre del buffer), START y END.
START y END especifican la porcion del buffer actual a copiar."
  (interactive
   (list (read-buffer "Agregar al buffer: " (other-buffer
                                            (current-buffer) t))
         (region-beginning) (region-end)))
  (let ((oldbuf (current-buffer)))
    (save-excursion
      (let* ((append-to (get-buffer-create buffer))
             (windows (get-buffer-window-list append-to t t))
             point)
        (set-buffer append-to)
        (setq point (point))
        (barf-if-buffer-read-only)
        (insert-buffer-substring oldbuf start end)
        (dolist (window windows)
          (when (= (window-point window) point)
            (set-window-point window (point))))))))

Se puede entender la función si se mira como una serie de plantillas llenas.

La plantilla exterior es para la definición de función. Esta función, se ve asi (con varios espacios ocupados):

(defun append-to-buffer (buffer start end)
  "documentacion…"
  (interactive …)
  cuerpo…)

La primer línea de la función incluye su nombre y tres argumentos. Los argumentos son el buffer al cual copiar el texto, start y end que son el inicio y el fin de la región del búfer actual que se va a copiar.

La siguiente parte de la función es la documentación, que es clara y completa. Como es convencional, los tres argumentos se escriben en mayúsculas para que los notes con facilidad. Aun mejor, se describen en el mismo orden que en la lista de argumentos.

Observa que la documentación distingue entre un búfer y su nombre. (La función puede manejar cualquiera.)

Ya que la función append-to-buffer se puede utilizar de forma interactiva, la función debe tener una expresión interactive. (Para una analisis de interactive, consulta la seccion Crear una función interactiva.) La expresión se lee de la siguiente manera:

(interactive
 (list (read-buffer
        "Agregar al buffer: "
        (other-buffer (current-buffer) t))
       (region-beginning)
       (region-end)))

Esta expresión no tiene letras que representen partes, como se describio anteriormente. En su lugar, inicia una lista con estas partes:

La primer parte de la lista es una expresión para leer el nombre de un búfer y devolverlo como una cadena. Es decir read-buffer. La función requiere un prompt como primer argumento, ‘"Agregar al buffer: "’. El segundo argumento le indica al comando que valor proporcionar si no se especifica nada.

En este caso ese segundo argumento es una expresión que contiene la función other-buffer, una excepción, y una ‘t’, que significa verdadero.

El primer argumento de other-buffer, la excepción, es otra función, current-buffer. Esto no va a ser devuelto. El segundo argumento es el símbolo de verdadero, t. Que le dice a other-buffer que puede mostrar búfers visibles (excepto en este caso, que no mostrará el búfer actual, lo cual tiene sentido).

La expresión se ve asi:

(other-buffer (current-buffer) t)

El segundo y tercer argumento de la expresión list son (region-beginning) y (region-end). Estas dos funciones especifican el inicio y el final del texto a añadir.

Originalmente, el comando utilizaba las letras ‘B’ y ‘r’. Toda la expresión interactive se veia así:

(interactive "BAppend to buffer: \nr")

Pero cuando se hacia esto, el valor por defecto del búfer de cambió era invisible. Esto no era lo que se queria.

(El prompt se separo del segundo argumento con una línea nueva, ‘\n’. Seguido por un ‘r’ que le indica a Emacs unir los dos argumentos que siguen al símbolo buffer en la lista de argumentos de la función (es decir, start y end) a los valores del punto y marca. Este argumento funcionaba bien.)

El cuerpo de la función append-to-buffer inicia con let.

Como hemos visto antes (Seccion let), el propósito de una expresión let es crear y dar valores iniciales a una o más variables que solo se usaran dentro del cuerpo del let. Esto significa que esa variable no se confundira con ninguna variable del mismo nombre fuera de la expresión let.

Podemos ver como la expresión let encaja en la función como un todo mostrando una plantilla de append-to-buffer con la expresión let en el esquema:

(defun append-to-buffer (buffer start end)
  "documentacion…"
  (interactive …)
  (let ((variable valor))
        cuerpo…)

La expresión let tiene tres elementos:

1. El símbolo let;

2. Una varlist que contiene, en este caso, una unica lista de dos elementos, (variable valor);

3. El cuerpo de la expresión let.

En la función append-to-buffer, la varlist es la siguiente:

(oldbuf (current-buffer))

En esta parte de la expresión let, la unica variable, oldbuf se liga al valor devuelto por la expresión (current-buffer). La variable, oldbuf, se utiliza para guardar un registro del búfer en el que se está trabajando y desde el que se va a copiar.

El elemento o elementos de una varlist estan rodeados por un conjunto de paréntesis por lo que el intérprete Lisp puede distinguir la varlist del cuerpo del let. Como consecuencia, la lista de dos elementos dentro de la varlist está rodeada por un conjunto circunscrito de paréntesis. La línea tiene este aspecto:

(let ((oldbuf (current-buffer)))
  … )

Los dos paréntesis antes de oldbuf podrían sorprenderte si no fuera porque el primer paréntesis marca el límite de la varlist y el segundo paréntesis marca el inicio de la lista de dos elementos, (oldbuf (current-buffer)).

El cuerpo de la expresión let dentro de append-to-buffer consiste en una expresión save-excursion.

La función save-excursion guarda las posiciones de punto y marca, y restaura estas posiciones después de que las expresiones en el cuerpo de save-excursion completan su ejecución. Además, save-excursion no pierde de vista el búfer original, y lo restaura. Asi es como se utiliza save-excursion en append-to-buffer.

Por cierto, vale la pena señalar que una función Lisp normalmente se formatea de modo que todo lo que esta encerrado en un conjunto de multiples lineas se indente más a la derecha que el primer símbolo. En esta definición de función, let se indenta más que defun, y save-excursion se indenta más que let y asi sucesivamente:

(defun …
  …
  …
  (let…
    (save-excursion
      …

Esta convención de formato hace que sea fácil ver que líneas en el cuerpo de save-excursion estan rodeadas por los parentesis asociados con save-excursion, de la misma manera que save-excursion esta rodeada por los paréntesis asociados con let:

(let ((oldbuf (current-buffer)))
  (save-excursion
    …
    (set-buffer …)
    (insert-buffer-substring oldbuf start end)
    …))

El uso de la función save-excursion puede verse como un proceso de rellenar las ranuras de una plantilla:

(save-excursion
  primer-expresion-en-el-cuerpo
  segunda-expresion-en-el-cuerpo
   …
  ultima-expresion-en-el-cuerpo)

En esta función, el cuerpo de save-excursion contiene solo una expresión, la expresión let*. Ya conoces la función let. La función let* es diferente. Posee un ‘*’ en su nombre. Esto le permite a Emacs colocar cada variable de su varlist en secuencia, una después de otra.

Su caracteristica fundamental es que las siguientes variables en la varlist puedan hacer uso de los valores establecidos por Emacs anteriormente en la varlist. Consulta la Seccion La expresión let*.

Vamos a omitir funciones como let* y nos centraremos en dos: la función set-buffer y la función insert-buffer-substring.

En los viejos tiempos, la expresión set-buffer era simplemente:

(set-buffer (get-buffer-create buffer))

pero ahora es

(set-buffer append-to)

append-to esta ligado al (get-buffer-create-buffer) anterior en la expresión let*. Esta union extra no sería necesaria excepto que append-to se utiliza despues en la varlist como un argumento para get-buffer-window-list.

La definición de la función append-to-buffer inserta texto desde el búfer en el que te encuentras actualmente al buffer que se indique. Sucede que insert-buffer-substring copia texto desde otro búfer al búfer actual, justo al reves––es por ello que la definición append-to-buffer inicia con un let que une el símbolo local oldbuf al valor devuelto por current-buffer.

La expresión insert-buffer-substring es la siguiente:

(insert-buffer-substring oldbuf start end)

La función insert-buffer-substring copia una cadena desde el búfer especificado como su primer argumento e inserta la cadena dentro del búfer actual. En este caso, el argumento de insert-buffer-substring es el valor de la variable creada y vinculada por let, es decir, el valor de oldbuf, que era el búfer actual cuando se dio el comando append-to-buffer.

Después de que insert-buffer-substring ha hecho su trabajo, save-excursion restaurará la acción al búfer original y append-to-buffer habrá hecho su trabajo.

Escrito en forma esqueletal, los funcionamientos del cuerpo se ven asi:

(let (unir-oldbuf-al-valor-del-buffer-actual)
  (save-excursion                       ; guarda un registro del buffer.
    cambio-de-buffer
    insertar-subcadena-desde-oldbuf-a-buffer)

  regresar-al-buffer-original-al-terminar
dejar-que-el-siginificado-local-de-oldbuf-desaparacesca-al-terminar

En resumen, append-to-buffer funciona de la siguiente manera: guarda el valor del búfer actual en la variable oldbuf. Obtiene el nuevo búfer (creando uno si es necesario) y cambia la atención de Emacs a este. Usando el valor de oldbuf, inserta la región del texto desde el búfer antiguo dentro del nuevo búfer; y luego usando save-excursion, regresa al búfer original.

Al observar append-to-buffer, se ha explorado una función bastante compleja. Muestra como usar let y save-excursion, y como cambiar y volver desde otro buffer. Muchas definiciones de función usan let, save-excursion, y set-buffer de esta manera.

Aquí está un breve resumen de las diferentes funciones descritas en este capítulo.

describe-function, describe-variable

Imprimen la documentación de una función o variable. Convencionalmente unidas a C-h f y C-h v.

find-tag

Encuentra el fichero que contiene el codigo de una función o variable y cambia a dicho buffer, colocando el punto al inicio del elemento. Convencionalmente ligado a M-. (esto es un punto luego de la tecla META).

save-excursion

Guarda la posicion de punto y marca y restaura sus valores tras evaluar los argumentos de save-excursion. Ademas, recuerda el buffer actual y regresa a el.

push-mark

Establece la marca a una posicion y registra el valor de la marca anterior en el anillo de marcas. La marca es una ubicacion en el búfer que mantendra su posición relativa, incluso si se añade o borra texto del búfer.

goto-char

Establece el punto a la ubicacion especificada por el valor del argumento, que puede ser un número, una marca, o una expresión que devuelve el número de una posición, como (point-min).

insert-buffer-substring

Copia una región de texto desde un búfer que se pasa a la función como argumento e inserta la región dentro del búfer actual.

mark-whole-buffer

Marca el búfer completo como una región. Normalmente unido a C-x h.

set-buffer

Cambia la atención de Emacs a otro búfer, pero no se muestra el cambio en la ventana. Se utiliza cuando un programa y no un humano trabaja en un búfer distinto.

get-buffer-create, get-buffer

Busca un búfer con nombre o crea uno si el búfer con ese nombre no existe. La función get-buffer devuelve nil si el nombre del búfer no existe.

• Escribe tu propia definición de la función end-of-buffer-simplicifado; luego pruebala para ver si funciona.

• Utiliza if y get-buffer para escribir una función que imprima un mensaje que indique si un buffer existe.

• Usando find-tag, busca el codigo de la función copy-to-buffer

En este capítulo, nos basamos en lo que hemos aprendido en los capítulos anteriores al analizar funciones más complejas. La función copy-to-buffer ilustra el uso de dos expresiones save-excursion en una definición, mientras que la función insert-buffer ilustra el uso de un asterisco en una expresión interactive, el uso de or, y la importante distinción entre un nombre y el objeto al que el nombre hace referencia.

Después de comprender cómo trabaja append-to-buffer, es fácil entender copy-to-buffer. Esta función copia texto dentro de un búfer, pero en lugar de agregarlo al segundo búfer, sustituye todo el texto en el segundo búfer.

El cuerpo de copy-to-buffer tiene este aspecto,

…
(interactive "BCopy to buffer: \nr")
(let ((oldbuf (current-buffer)))
  (with-current-buffer (get-buffer-create buffer)
    (barf-if-buffer-read-only)
    (erase-buffer)
    (save-excursion
      (insert-buffer-substring oldbuf start end)))))

La función copy-to-buffer tiene una expresión interactive mas sencilla que append-to-buffer.

La definición dice:

(with-current-buffer (get-buffer-create buffer) …

En primer lugar, mira la expresión más interna; que se evalua primero. Esta expresión inicia con get-buffer-create buffer. La función le indica al ordenador que utilice el búfer con el nombre específicado como aquel que quieres copiar, o si tal búfer no existe, que lo cree. Luego, la función with-current-buffer evalúa su cuerpo con este búfer temporal.

(Esto demuestra otra forma de cambiar la atención del ordenador pero no la del usuario. La función append-to-buffer muestro como hacer lo mismo con save-excursion y set-buffer. with-current-buffer es un mecanismo nuevo, y posiblemente mas sencillo.)

La función barf-if-buffer-read-only envía un mensaje de error diciendo que el búfer es de solo lectura si no se puede modificar.

La siguiente línea tiene como único contenido la función erase-buffer. Este función borra el búfer.

Finalmente, las últimas dos líneas contienen la expresión save-excursion con insert-buffer-substring como cuerpo. La expresión insert-buffer-substring copia el texto desde el búfer en el que te encuentras (y no has visto al ordenador cambiar su atención, por lo que no sabes que ese búfer ahora se llama oldbuf).

Por cierto, esto es lo que se entiende por ‘reemplazo’. Para reemplazar el texto Emacs borra el texto anterior y luego inserta un texto nuevo.

A grandes rasgos, el cuerpo de copy-to-buffer se ve asi:

(let (enlazar-oldbuf-al-valor-del-bufer-actual)
    (con-el-bufer-al-que-estas-copiando
      (pero-no-borrar-o-copiar-a-un-bufer-de-solo-lectura)
      (erase-buffer)
      (save-excursion
        insertar-la-subcadena-desde-oldbuf-en-el-bufer)))

insert-buffer es otra función relacionada con búfers. Este comando copia otro búfer dentro del búfer actual. Es lo contrario a append-to-buffer o copy-to-buffer, dado que copia una región de texto desde el búfer actual a otro búfer.

Aquí examinamos en el código original. El código se simplifico en 2003 y es mas dificil de entender.

(Consulta la Seccion Nuevo Cuerpo para insert-buffer, para ver una discusión del nuevo cuerpo.)

Además, este código ilustra el uso de interactive con un búfer que podría ser read-only (de solo lectura) y la importante distinción entre el nombre de un objeto y el objeto al que realmente hace referencia.

Aquí está el código anterior:

(defun insert-buffer (buffer)
  "Insertar despues del punto el contenido de BUFFER.
Coloca la marca despues del texto insertado.
BUFFER puede ser un buffer o el nombre de un buffer."
  (interactive "*bInsert buffer: ")
  (or (bufferp buffer)
      (setq buffer (get-buffer buffer)))
  (let (start end newmark)
    (save-excursion
      (save-excursion
        (set-buffer buffer)
        (setq start (point-min) end (point-max)))
      (insert-buffer-substring buffer start end)
      (setq newmark (point)))
    (push-mark newmark)))

Al igual que con otras definiciones de función, se puede usar una plantilla para ver un esquema de la función:

(defun insert-buffer (buffer)
  "documentacion…"
  (interactive "*bInsert buffer: ")
  cuerpo…)

En insert-buffer, el argumento de la declaración interactive tiene dos partes, un asterisco, ‘*’, y ‘bInsert buffer: ’.

El asterisco se utliza cuando el búfer actual es un búfer de solo lectura––un búfer que no se puede modificar. Si se llama a insert-buffer cuando el búfer actual es de solo lectura, se imprime un mensaje en el area de eco y el terminal puede emitir un beep o parpadear; no se permitira insertar nada en el búfer actual. El asterisco no tiene que ser seguido por un salto de linea para separarlo del siguiente argumento.

El siguiente argumento de la expresión interactiva inicia con una letra ‘b’ minúscula. (Esto es diferente del código para append-to-buffer, que utiliza una ‘B’ mayúscula. Consulta la Seccion La Definición de append-to-buffer.) La ‘b’ minúscula le indica al intérprete Lisp que el argumento de insert-buffer debe ser un buffer existente o su nombre. (La opcion ‘B’ mayúscula permite la posibilidad de que el búfer no exista.) Emacs te pedira el nombre del búfer, ofreciendo un búfer por defecto, con el autocompletado de nombre habilitado. Si el búfer no existe, recibiras un mensaje que dice “No match” (no concuerda); tu terminal tambien puede emitir un beep.

El nuevo código simplificado genera una lista para interactive. Este utiliza las funciones barf-if-buffer-read-only y read-buffer con las que ya estamos familiarizados y la forma especial progn con la que no lo estamos. (Se describira mas adelante).

El cuerpo de la función insert-buffer tiene dos partes principales: una expresión or y una expresión let. El propósito de la expresión or es asegurar que el argumento buffer esta ligado a un búfer y no solo al nombre de un búfer. El cuerpo de la expresión let contiene el código que copia el otro búfer dentro del búfer actual.

A grades rasgos, las dos expresiones encajan asi en la función insert-buffer:

(defun insert-buffer (buffer)
  "documentacion…"
  (interactive "*bInsert buffer: ")
  (or …
      …
  (let (varlist)
      cuerpo-de-let… )

Para entender como la expresión or asegura que el argumento buffer esta unido a un búfer y no al nombre de un búfer, primero es necesario entender la función or.

Antes de hacer esto, permíteme reescribir esta parte de la función utilizando if de esta manera puedes ver como se hace de una manera que resulte familiar.

El trabajo a realizar es asegurarse de que el valor de buffer sea un búfer en sí mismo y no el nombre de un búfer. Si el valor es el nombre, entonces debe optenerse el búfer en sí.

Puedes imaginarte a tí mismo en una conferencia donde un acomodador está observando una lista con tu nombre en ella y mirándote: el acomodador sabe “asociar” tu nombre, no a tí; pero cuando el acomodador te encuentra y te toma el brazo, el acomodador lo “asocia” a tí.

En Lisp, se podría describir esta situación así:

(if (not (tomar-al-invitado))
    (encontrar-y-tomar-del-brazo-al-invitado))

Queremos hacer lo mismo con un búfer––si no tenemos el búfer en sí, queremos conseguirlo.

Usando un predicado llamado bufferp que nos informa si tenemos un búfer (en lugar de su nombre), podemos escribir el código de esta manera:

(if (not (bufferp buffer))              ; parte-if
    (setq buffer (get-buffer buffer)))  ; parte-then

Aquí, la prueba verdadero-o-falso de la expresión if es (not (bufferp buffer)); y la parte then es la expresión (setq buffer (get-buffer buffer)).

En la prueba, la función bufferp devuelve verdadero si su argumento es un búfer––sino falso si el argumento es el nombre del búfer. (El último carácter del nombre de la función bufferp es el carácter ‘p’; como vimos anteriormente, tal uso de ‘p’ es una convención que indica que la función es un predicado, que es un término que significa que la función determinará si alguna propiedad es verdadera o falsa. Consulta la Seccion Usando el tipo incorrecto de objeto como argumento.)

La función not precede a la expresión (bufferp buffer), así la prueba verdadero-o-falso es la siguente:

(not (bufferp buffer))

not es una función que devuelve verdadero si su argumento es falso y falso si su argumento es verdadero. Por lo que si (bufferp buffer) devuelve verdadero, la expresión not devuelve falso y viceversa: lo que es “no verdadero” es falso y lo que es “no falso” es verdadero.

Usando esta prueba, la expresión if funciona de la siguiente manera: cuando el valor de la variable buffer es realmente un búfer en lugar de su nombre, la prueba verdadero-o-falso devuelve falso y la expresión if no evalúa la parte-then. Esto está bien, ya que no tenemos que hacer nada para la variable buffer si realmente es un búfer.

Por otro lado, cuando el valor de buffer no es un buffer en sí, pero si el nombre de un buffer, la prueba verdadero-o-falso devuelve verdadero y se evalua la parte-then de la expresión. En este caso, la parte-then es (setq buffer (get-buffer buffer)). Esta expresión utiliza la función get-buffer para devolver un buffer real, dado su nombre. Luego setq asigna la variable buffer reemplazando su valor anterior (que era el nombre del búfer).

El propósito de la expresión or en la función insert-buffer es asegurar que el argumento buffer está ligado a un búfer y no solo al nombre de uno. La sección previa muestra como se podría haber hecho el trabajo usando una expresión if. Sin embargo, la función insert-buffer utiliza or. Para entender esto, es necesario entender como funciona or.

Una función or puede tener cualquier número de argumentos. Evalúa un argumento a la ves y devuelve el valor del primero de sus argumentos que no es nil. Ademas, y esta es una caracteristica crucial de or, no evalúa ningun argumento posterior después de regresar el primer valor no-nil.

La expresión or se ve asi:

(or (bufferp buffer)
    (setq buffer (get-buffer buffer)))

El primer argumento de or es la expresión (bufferp buffer). Esta expresión devuelve verdadero (un valor no-nil) si el búfer es realmente un búfer, y no solo el nombre de un búfer. En la expresión or, si este es el caso, la expresión or devuelve este valor verdadero y no evalúa la siguiente expresión––y esto esta bien para nosotros, ya que no queremos hacer nada con el valor de buffer si realmente es un búfer.

Por otro lado, si el valor de (bufferp buffer) es nil, que lo sera si el valor de buffer es el nombre de un buffer, el intérprete Lisp evalúa el siguiente elemento de la expresión. Esta es la expresión (setq buffer (get-buffer buffer)). Esta expresión devuelve un valor no-nil, que es el valor al que establece la variable buffer––y este valor es un búfer en sí, no el nombre de un búfer.

El resultado de todo esto es que el símbolo buffer siempre esta ligado a un búfer en sí mismo y no al nombre de uno. Todo esto es necesario porque la función set-buffer en la línea siguiente solo funciona con un buffer en sí, no con el nombre de un búfer.

A proposito, usando or, la escena con el acomodador se escribiria así:

(or (tomar-al-invitado) (encontrar-y-tomar-del-brazo-al-invitado))

Después de asegurarse que la variable buffer se refiere a un buffer en sí y no solo al nombre de uno, la función insert-buffer continúa con una expresión let. Esta especifica tres variables locales, start, end y newmark y las une al valor inicial nil. Estas variables se utilizan dentro del resto de let y ocultan temporalmente cualquier otra ocurrencia de variables con el mismo nombre en Emacs hasta el final de let.

El cuerpo de let contiene dos expresiones save-excursion. Primero, veremos la expresión interna save-excursion en detalle. La expresión se ve asi:

(save-excursion
  (set-buffer buffer)
  (setq start (point-min) end (point-max)))

La expresión (set-buffer buffer) cambia la atención de Emacs del búfer actual al buffer desde donde se copiara el texto. En ese búfer las variables start y end se asignan al inicio y al fin del búfer, usando los comandos point-min y point-max. Observa que tenemos aquí un ejemplo de cómo setq es capaz de asignar dos variables en la misma expresión. El primer argumento de setq se establece al valor del segundo, y el tercer argumento se establece al valor del cuarto.

Después de evaluar el interior del cuerpo de save-excursion, save-excursion restaura el búfer original, pero start y end retienen los valores del inicio y fin del búfer del que se copiara el texto.

La expresión extena de save-excursion luce asi:

(save-excursion
  (expresion-interior-de-save-excursion
     (ir-al-nuevo-bufer-y-establecer-start-y-end)
  (insert-buffer-substring buffer start end)
  (setq newmark (point)))

La función insert-buffer-substring copia el texto dento del búfer actual desde la región indicada por start y end en el buffer. Puesto que la totalidad del segundo búfer se encuentra entre start y end, todo dentro del segundo búfer se copia el bufer que se esta editando. A continuacion, el valor del punto, que estara al final del texto insertado, se registra en la variable newmark.

Después de evaluar el cuerpo del save-excursion externo, el punto y la marca se vuelven a colocar en su posicion original.

Sin embargo, es conveniente ubicar una marca al fin del texto recien insertado y ubicar el punto al principio. La variable newmark registra el fin del texto insertado. En la última línea de la expresión let, la expresión (push-mark newmark) asigna una marca a esta posición. (La posición anterior de la marca aun es accesible; se registra en el anillo de marcas y puedes volver a ella con C-u C-SPC.) Mientras tanto, el punto se encuentra al principio del texto insertado, que es donde estaba antes de llamar a la función de insercion, cuya posición fue guardada por la primer save-excursion.

La expresión let completa se ve asi:

(let (start end newmark)
  (save-excursion
    (save-excursion
      (set-buffer buffer)
      (setq start (point-min) end (point-max)))
    (insert-buffer-substring buffer start end)
    (setq newmark (point)))
  (push-mark newmark))

Al igual que la función append-to-buffer, la función insert-buffer utiliza let, save-excursion y set-buffer. Además, la función ilustra una forma de utilizar or. Todas estas funciones son bloques de construccion que vamos a encontrar y utilizar una y otra vez.

El cuerpo en la versión 22 de GNU Emacs es más confuso que el original.

Se compone de dos expresiones

(push-mark
 (save-excursion
   (insert-buffer-substring (get-buffer buffer))
   (point)))

nil

excepto que, y esto es lo que confunde a los novatos, se hace un trabajo muy importante al interior de la expresión push-mark.

La función get-buffer devuelve un búfer con el nombre proporcionado. Notaras que la función no se llama get-buffer-create; no crea un búfer si no existe ya. El búfer devuelto por get-buffer, un búfer existente, se pasa a insert-buffer-substring, que inserta todo el búfer (ya que no se especifica ninguna cosa más).

La posición en la que se inserta el buffer se registra por push-mark. Despues la función devuelve nil, el valor de su último comando. Dicho de otra manera, la función insert-buffer existe solo para producir un efecto secundario, insertando otro buffer, no para devolver ningun valor.

Ya se ha discutido la estructura básica de la función beginning-of-buffer. (Consulta la Seccion Una definición simplificada de beginning-of-buffer). Esta sección describe la parte compleja de la definición.

Como se ha descrito anteriormente, cuando se invoca a beginning-of-buffer sin argumento, mueve el cursor al inicio del búfer (en realidad, al inicio de la porción accesible del búfer), dejando la marca en la posición anterior. Sin embargo, cuando el comando se invoca con un número entre uno y diez, la función considera que ese número es una fracción del tamaño del búfer, medido en decimas, y Emacs mueve el cursor a dicha fracción del reccorrido desde el inicio del búfer. Por lo tanto, puedes llamar a esta función con el comando de teclado M-<, que moverá el cursor al principio del búfer, o con un comando de teclado como C-u 7 M-< que moverá el cursor a un 70% del recorrido a través del búfer. Si se utiliza un número mayor a diez como argumento, se movera al final del búfer.

La función beginning-of-buffer puede llamarse con o sin argumentos. El uso del argumento es opcional.

A menos que se diga lo contrario, Lisp espera que una función con un argumento en su definición de función se llamada con un valor para ese argumento. Si esto no ocurre, se obtiene un error y un mensaje que dice ‘Wrong number of arguments’ (Número de argumentos erróneo).

Sin embargo, los argumentos opcionales son una caracteristica de Lisp: se utiliza una palabra clave particular para decirle al intérprete Lisp que un argumento es opcional. La palabra clave es &optional. (El ‘&’ al frente de ‘optional’ es parte de la palabra clave.) En una definición de función, si un argumento va despues de la palabra clave &optional, no es necesario pasar ningún valor a ese argumento al llamar a la función.

Por lo tanto la primera línea de la definición de función de beginning-of-buffer tiene este aspecto:

(defun beginning-of-buffer (&optional arg)

En lineas generales, toda la función luce asi:

(defun beginning-of-buffer (&optional arg)
  "documentacion…"
  (interactive "P")
  (or (es-el-argumento-una-cons-cell argumento)
      (and ambos-transient-mark-mode-y-mark-active-son-verdadero)
      (push-mark))
  (let (determina-el-tamano-y-lo-establece)
  (goto-char
    (si-hay-un-argumento
        averigua-donde-ir
      de-otro-modo-va-a
      (point-min))))
   do-nicety

La función es similar a la función beginning-of-buffer-simplificado excepto que la expresión interactive tiene "P" como argumento y la función goto-char es seguida por una expresión if-then-else que calcula donde poner el cursor si hay un argumento que no es un cons cell.

(Puesto que no explico que es un cons cell en muchos capítulos, por favor, considera ignorar la función consp. Consulta la Seccion Cómo se implementan las listas, y la Seccion Cons Cell y Tipos de Listas en El Manual de Referencia GNU Emacs Lisp).

La "P" en la expresión interactive le indica a Emacs que pase un argumento prefijo, si lo hay, en su forma plana sin procesar. Un argumento prefijo se crea presionando la tecla META seguida por un número, o pulsando C-u y luego un número. (Si no escribes un número, C-u por defecto pasa un cons cell con un 4. Una "p" minúscula en la expresión interactive hace que la función convierta un argumento prefijo a un número.)

La prueba verdadero-o-falso de la expresión if parece compleja, pero no lo es: comprueba si arg tiene un valor que no es nil y si es un cons cell. (Esto es lo que hace consp; comprueba si su argumento es un cons cell.) Si arg tiene un valor distinto a nil (y no es un cons cell), que será el caso si beginning-of-buffer se llama con un argumento numerico, la prueba verdadero-o-falso devolverá verdadero y se evaluara la parte-then de la expresión if. Por otro lado, si beginning-of-bufer no se llama con un argumento, el valor de arg será nil y se evaluara la parte-else de la expresión if. La parte-else es simplemente point-min, y cuando este es el resultado, toda la expresión goto-char es (goto-char (point-min)), que es cómo vimos la función beginning-of-buffer en su forma simplificada.

Cuando se llama a beginning-of-buffer con un argumento, se evalua una expresión que calcula que valor pasar a goto-char. A primera vista esta expresion es bastante compleja. Incluye una expresión if y mucha aritmética. Se ve así:

(if (> (buffer-size) 10000)
    ;; Evita el desbordamiento en buffers de gran tamaño!
    (* (prefix-numeric-value arg)
       (/ size 10))
  (/ (+ 10
        (* size (prefix-numeric-value arg)))
     10))

Como otras expresiones que parecen complejas, la expresión condicional dentro de beginning-of-buffer se puede desenredar viendola como partes de una plantilla, en este caso, con la plantilla para una expresión if-then-else. En forma esquelética, la expresión se ve así:

(if (buffer-es-grande
    divide-el-tamaño-del-buffer-por-10-y-multiplicalo-por-arg
  de-otra-forma-utiliza-el-calculo-alternativo

La prueba verdadero-o-falso de la expresión if interna comprueba el tamaño del buffer. La razón de esto es que la vieja versión de Emacs 18 utilizaba números que no superaban los ocho millones y en el siguiente calculo, el programador temía que Emacs pudiera intentar usar numeros demasiado grandes si el búfer era extenso. El término ‘desbordamiento’, que se menciona en el comentario, significa que los números son demaciado grandes. Las versiones más recientes de Emacs utilizan números mas grandes, pero este código no ha sido tocado, aunque solo sea porque la gente ahora mira búfers que son mucho, mucho mas grandes que antes.

Hay dos casos: si el búfer es grande, o si no lo es.

En beginning-of-buffer, la expresión if interna prueba si el tamaño del búfer es mayor a 10000 caracteres. Para ello, se utiliza la función > y el calculo de size que proviene de la expresión let.

En los viejos tiempos, se utilizaba la función buffer-size. No solo se llamo varias ocaciones esa funcion, sino que dio el tamaño de todo el búfer, no la parte accesible. El calculo tiene mucho más sentido cuando se maneja solo la parte accesible. (Consulta la Seccion Reducir y Extender, para obtener más información sobre como centrar la atención en una parte ‘accesible’.)

La linea se ve asi:

(if (> size 10000)

Cuando el búfer es grande, se evalua la parte-then de la expresión if. Se lee así (después de formatearlo para facilitar la lectura):

(*
  (prefix-numeric-value arg)
  (/ size 10))

Esta expresión es una multiplicación, con dos argumentos para la función *.

El primer argumento es (prefix-numeric-value arg). Cuando se usa "P" como argumento para interactive, el valor pasado a la función como argumento es un “argumento prefijo en bruto”, y no un número. (Es un número en una lista). Para realizar el calculo, se necesita una conversión, y prefix-numeric-value hace el trabajo.

El segundo argumento es (/ size 10). Esta expresión divide el valor numérico por diez––el valor numérico del tamaño de la porción accesible del búfer. Esto produce un número que indica cuántos caracteres componen una decima parte del tamaño del búfer. (En Lisp, / se utiliza para la división, igual que * se utiliza para la multiplicación.)

En la expresión de multiplicación como un todo, esta cantidad se multiplica por el valor del argumento prefijo––la multiplicación es la siguiente:

(* valor-numerico-del-argumento-prefijo-arg
   numero-de-caracteres-en-una-decima-parte-de-la-porcion-accesible-del-buffer)

Si, por ejemplo, el argumento prefijo es ‘7’, el valor de una decima parte será multiplicado por 7 para dar una posición del 70% del trayecto.

El resultado de todo esto es que si la porción accesible del búfer es grande, la expresión goto-char es la siguiente:

(goto-char (* (prefix-numeric-value arg)
              (/ size 10)))

Esto coloca el cursor donde lo queremos.

Si el búfer contiene menos de 10,000 caracteres, se lleva a cabo un calculo ligeramente diferente. Podrías pensar que esto no es necesario, ya que el primer calculo podría hacer el trabajo. Sin embargo, en un búfer pequeño, el primer método puede no colocar el cursor exactamente en la línea deseada; el segundo método hace un mejor trabajo.

El código es el siguiente:

(/ (+ 10 (* size (prefix-numeric-value arg))) 10))

Para averiguar que ocure en este código debemos descubrir como se anidan las funciones entre paréntesis. Es mas fácil de leer si se reformatea cada expresión, indentando la expresión que contiene:

  (/
   (+ 10
      (*
       size
       (prefix-numeric-value arg)))
   10))

Observando los paréntesis, vemos que la operación mas profunda es (prefix-numeric-value arg), que convierte el argumento prefijo en bruto a un número. En la siguiente expresión, este número se multiplica por el tamaño de la porción accesible del búfer:

(* size (prefix-numeric-value arg))

Esta multiplicación crea un número que puede ser mayor al tamaño del buffer––siete veces mayor si el argumento es 7, por ejemplo. Luego se suma diez a éste numero y finalmente el número se divide por 10 para proporcionar un valor que es un carácter más grande que la posición porcentual en el búfer.

El número que resulta de todo esto se pasa a goto-char y el cursor se mueve a ese punto.

Aquí está el texto completo de la función beginning-of-buffer:

(defun beginning-of-buffer (&optional arg)
  "Mueve el punto al principio del bufer;
deja la marca en la posicion anterior.
Con el prefijo \\[universal-argument],
no establece la marca en la posicion anterior.
Con un argumento numerico N,
coloca el punto N/10 del camino desde el inicio.

Si el bufer tiene activo narrowing,
este comando utiliza el principio y el tamaño
de la parte accesible del bufer.

No utilice este comando en programas Lisp!
\(goto-char (point-min)) es mas rapido y evita
tocar la marca."
  (interactive "P")
  (or (consp arg)
      (and transient-mark-mode mark-active)
      (push-mark))
  (let ((size (- (point-max) (point-min))))
    (goto-char (if (and arg (not (consp arg)))
                   (+ (point-min)
                      (if (> size 10000)
                          ;; Evita el desbordamiento en los búfers de gran tamaño!
                          (* (prefix-numeric-value arg)
                             (/ size 10))
                        (/ (+ 10 (* size (prefix-numeric-value arg)))
                           10)))
                 (point-min))))
  (if arg (forward-line 1)))

Excepto por dos pequeños puntos, la discusión anterior muestra cómo funciona esta función. El primer punto se refiere a un detalle en la cadena de documentación, y el segundo se refiere a la última línea de la función.

En la cadena de documentación, hay una referencia a una expresión:

\\[universal-argument]

Se usa Un ‘\\’ antes del primer corchete de esta expresión. Este ‘\\’ le indica al intérprete Lisp que sustituya cualquier clave qué se encuentre dentro de ‘[…]’ por su convinacion de teclado actual. En el caso de universal-argument, suele ser C-u, pero podría ser distinta. (Consulta la Sección Consejos para Cadenas de Documentación en El Manual de Referencia de GNU Emacs Lisp, para más información.)

Finalmente, la última línea del comando beginning-of-buffer dice que hay que mover el punto al inicio de la siguiente línea si el comando se invoca con un argumento:

(if arg (forward-line 1)))

Esto coloca el cursor al inicio de la primer línea despues de la posicion inidicada en decimas en el búfer. Esto significa que el cursor siempre se localiza al menos las decimas del recorrido solicitadas del búfer, esta es una sutiliza, quizás, no necesaria, pero que, si no ocurriera, seguro suscitaria quejas.

Por otro lado, tambien significa que si se especifica el comando con C-u, pero sin un número, es decir, si el ‘argumento prefijo en bruto’ simplemente es un cons cell, entonces el comando te coloca al inicio de la segunda línea … no sé si se pretende esto o si nadie ha tratado el código para evitar que esto suceda.

He aquí un breve resumen de algunos de los temas cubiertos en este capítulo.

or

Evalúa cada argumento en secuencia, y devuelve el valor del primer argumento que no es nil, si ninguno devuelve un valor que no sea nil, devuelve nil. En resumen, devuelve el primer valor verdadero de los argumento; devuelve un valor verdadero si uno o cualquiera de los otros es verdadero.

and

Evalúa cada argumento en secuencia, y si alguno es nil, devuelve nil; si ninguno es nil, devuelve el valor del último argumento. En resumen, devuelve un valor verdadero solo si todos los argumentos son verdaderos; devuelve un valor verdadero si uno y cada uno de los otros son verdadero.

&optional

Una palabra clave utilizada para indicar que un argumento en una definición de función es opcional; esto significa que la función se puede evaluar sin el argumento, si se desea.

prefix-numeric-value

Convierte el ‘argumento prefijo en bruto’ producido por (interactive "P") en un valor numérico.

forward-line

Mueve el punto hacia adelante al principio de la siguiente línea, o si el argumento es mayor a uno, hacia delante varias líneas. Si no puede avanzar tanto hacia delante como se supone, forward-line va hacia adelante tan lejos como pueda y luego devuelve un conteo del número de líneas adicionales que debia avanzar poro no pudo.

erase-buffer

Elimina todo el contenido del búfer actual.

bufferp

Devuelve t si su argumento es un búfer; de otro modo devuelve nil.

Escribe una función interactiva con un argumento opcional que comprueve si su argumento, un número, es mayor o igual o menor que el valor de fill-column, y lo informe, en un mensaje. Sin embargo, si no se pasa un argumento a la función, utiliza 56 como valor por defecto.

La reduccion (narrowing) es una funcionalidad de Emacs que hace posible que puedas focalizarte en una parte específica de un búfer, y trabajar sin cambiar accidentalmente otras partes. La reduccion normalmente se deshabilita ya que puede confundir a los principiantes.

Con la reduccion, el resto del búfer se hace invisible, como si no estuviera alli. Esto es una ventaja si, por ejemplo, se quiere reemplazar una palabra en una parte del búfer pero no en otra: limitas la parte que deseas y el reemplazo se lleva a cabo solo en esa sección, no en el resto del búfer. Las búsquedas solo funcionarán con la región reducida, no fuera de ella, de esta forma si estás reparando una parte de un documento, puedes mantener fuera la parte que no necesitas. (El atajo asociado a narrow-to-region es C-x n n.)

Sin embargo, la reduccion hace invisible el resto del búfer, lo que puede asustar a quien invoca inadvertidamente la reduccion y piensa que ha eliminado una parte de su fichero. Ademas, el comando undo (usualmente ligado a C-x u) no desactiva la reduccion (ni debe hacerlo), por lo que las personas pueden llegar a desesperarse si no saben que pueden devolver el resto del buffer a la visibilidad cor el comando widen que es C-x n w.)

La reduccion es igual de util para el intérprete Lisp como para un humano. Con frecuencia, una función Emacs Lisp está diseñada para trabajar solo en parte de un búfer; o por el contrario, una función Emacs Lisp necesita trabajar en todo un búfer que ha sido reducido. La función what-line, por ejemplo, elimina la reduccion de un búfer, si este tiene alguna reduccion y al terminar su trabajo, restaura la reduccion. Por otro lado, la función count-lines utiliza la reduccion para restringirse a sí misma solo a la porción del búfer en la que se está interesado y luego restaura la situación anterior.

En Emacs Lisp, se puede utilizar la forma especial save-restriction para llevar un registro de cualquier reduccion en efecto. Cuando el intérprete Lisp se encuentra con save-restriction, ejecuta el código en el cuerpo de la expresión save-restriction, y luego deshace cualquier cambio en la reduccion causada por el código. Si, por ejemplo, el búfer es reducido y el código que sigue al comando save-restriction se deshace de la reduccion, save-restriction devuelve el búfer a su región reducida. En el comando what-line, cualquier reduccion del búfer puede anularse por el comando widen inmediatamente despues del comando save-restriction. Se restaura cualquier reduccion original justo antes de finalizar la función.

La plantilla para una expresión save-restriction es simple:

(save-restriction
  cuerpo… )

El cuerpo de save-restriction es una o más expresiones que seran evaluadas de forma secuencial por el intérprete Lisp.

Finalmente, un punto a tener en cuenta: cuando utilices save-excursion y save-restriction a la vez, una detras de la otra, debes utilizar save-excursion primero. Si lo escribes en orden inverso, es posible que no registre la reduccion en el búfer al que emacs debe cambiar Emacs despues de llamar a save-excursion. Por lo tanto, cuando escribas a la vez save-excursion y save-restriction debe ser así:

(save-excursion
  (save-restriction
    cuerpo…))

En otras circunstancias, cuando no se escriban a la vez, las formas especiales save-excursion y save-restriction deben escribirse en el orden adecuado para la función.

Por ejemplo,

(save-restriction
  (widen)
  (save-excursion
  cuerpo…))

El comando what-line informa el número de la línea en la que el cursor esta colocado. La función ilustra el uso de los comandos save-restriction y save-excursion. Aquí está el texto original de la función:

(defun what-line ()
  "Imprime el numero de linea actual (en el bufer) del punto."
  (interactive)
  (save-restriction
    (widen)
    (save-excursion
      (beginning-of-line)
      (message "Line %d"
               (1+ (count-lines 1 (point)))))))

(En versiones recientes de GNU Emacs, la función what-line se ha ampliado para decirte el numero de linea en un búfer reducido, asi como el número de línea en un búfer extendido. La versión reciente es más compleja que la versión que se muestra aqui. Si te sientes aventurero, puede que quieras verla despues de averiguar como funciona esta version. Probablemente necesites utilizar C-h f (describe-function). La nueva versión utiliza un condicional para determinar si se ha reducido el búfer.

(También, utiliza line-number-at-pos, que entre otras expresiones sencillas, como (goto-char (point-min)), mueve el punto al inicio de la línea actual con (forward-line 0) en lugar de beginning-of-line.)

La función what-line que se muestra aqui tiene una línea de documentación y es interactiva, como es de esperar. Las dos líneas siguientes utilizan las funciones save-restriction y widen.

La forma especial save-restriction observa cualquier reduccion activa en el buffer actual y restaura la reduccion despues de evaluar el código de su cuerpo.

La forma especial save-restriction es seguida por widen. Esta función deshace cualquier reduccion que pudiera haber tenido el búfer actual cuando se llama a what-line. (La reduccion que estaba alli es la reduccion que save-restriction recuerda.) Esta ampliación hace posible que los comandos para el conteo de lineas cuenten desde el inicio del búfer. De lo contrario, se habría limitado a contar dentro de la región accesible. Cualquier reduccion original se restaura justo antes de completar la funcion por la forma especial save-restriction.

La llamada a widen es seguida por save-excursion, que guarda la posición del cursor (es decir, el punto) y la marca, y los restaura después de que el código en el cuerpo de save-excursion utiliza la función beginning-of-line para mover el punto.

(Ten en cuenta que la expresión (widen) ocurre entre las formas especiales save-restriction y save-excursion. Cuando escribas las dos expresiones save-… consecutivamente, escribe save-excursion primero.)

Las dos últimas líneas de la función what-line son funciones para contar el número de líneas en el búfer y luego imprimir el número en el área de eco.

(message "Line %d"
         (1+ (count-lines 1 (point)))))))

La función message imprime un mensaje de una línea en la parte inferior de la pantalla de Emacs. El primer argumento esta dentro de comillas y se imprime como una cadena de caracteres. Sin embargo, contiene una expresión ‘%d’ para imprimir el siguiente argumento. ‘%d’ imprime el argumento como un decimal, por lo que el mensaje dirá algo como ‘Línea 243’.

El número que se imprime en lugar del ‘%d’ se calcula por la última línea de la función:

(1+ (count-lines 1 (point)))

Lo que esto hace es contar las líneas desde la primer posición del búfer indicada por el 1, hasta (point), y luego sumar uno a este número. (La función 1+ suma uno a su argumento.) Se suma uno porque la línea 2 tiene solo una línea antes de ella, y count-lines cuenta solo las líneas antes de la línea actual.

Después que count-lines termina su trabajo, y se imprime el mensaje en el área de eco, la función save-excursion restaura el punto y marca a sus posiciones originales; y save-restriction restaura la reduccion original, si la hubiera.

Escribe una función que muestre los primeros 60 caracteres del búfer actual, incluso si has reducido el búfer a la mitad de modo que la primer línea sea inaccesible. Restaura el punto, marca y la reduccion. Para este ejercicio, necesitas utilizar todo un popurri de funciones, incluyendo save-restriction, widen, goto-char, point-min, message, y buffer-substring.

(buffer-substring es una función que aun no se menciona, tendrás que investigarla por tu cuenta; o quizás tengas que utilizar buffer-substring-no-properties o filter-buffer-substring …, u otras funciones. Las propiedades de texto son una funcionalidad que no sera discutida aquí. Consulta la Seccion Propiedades de Texto en El Manual de Referencia de Emacs Lisp.)

Además, ¿realmente se necesita goto-char o point-min? ¿O se puede escribir la función sin ellas?

En Lisp, car, cdr, y cons son funciones fundamentales. La función cons se utiliza para construir listas, y las funciones car y cdr se utilizan para desmontarlas.

En el recorrido a través de la función copy-region-as-kill, veremos cons, asi como dos variantes de cdr, llamadas setcdr y nthcdr. (Consulta la Sección copy-region-as-kill.)

El nombre de la función cons no es irazonable: es una abreviatura de la palabra ‘construct’ (construir). Por otra parte, el origen de los nombres car y cdr, es esoterico: car es un acrónimo de la frase ‘Contents of the Address part of the Register’ (Contenidos de las Direcciónes parte del Registro); y cdr (pronunciado ‘could-er’) es un acrónimo de la frase ‘Contents of the Decrement part of the Register’ (Contenidos de la parte de Decremento del Registro). Estas frases se refieren a piezas específicas de hardware en el ordenador en el que se desarrollo el Lisp original. Ademas de ser obsoletas, las frases han sido completamente irrelevantes por más de 25 años para cualquiera que piense en Lisp. No obstante, aunque algunos pocos académicos valientes han empezado a utilizar nombres más razonables para estas funciones, los viejos términos aun continuan en uso. En particular, dado que los términos se utilizan en el código fuente de Emacs Lisp, los usaremos en esta introducción.

El car de una lista es sencillamente, el primer elemento de la lista. De este modo, el car de la lista (rosa violeta margarita tulipan) es rosa.

Si estás leyendo esto dentro de GNU Emacs, puedes verlo evaluando lo siguiente:

(car '(rosa violeta margarita tulipan))

Después de evaluar la expresión, aparecerá rosa en el área de eco.

Claramente, un nombre más razonable para la función car sería first y esto es con frecuencia lo que se sugiere.

car no elimina el primer elemento de la lista; solo informa de lo que es. Después de aplicar car a una lista, la lista sigue siendo la misma que antes. En la jerga, car es ‘no destructiva’. Esta caracteristica resulta ser importante.

El cdr de una lista es el resto de la lista, es decir, la función cdr devuelve la parte de la lista que sigue al primer elemento. Por lo tanto, mientras que el car de la lista '(rosa violeta margarita tulipan) es rosa, el resto de la lista, el valor devuelto por la función cdr, es (violeta margarita tulipan).

Puedes ver esto evaluando lo siguiente del modo habitual:

(cdr '(rosa violeta margarita tulipan))

Al evaluar esto, aparece (violeta margarita tulipan) en el área de eco.

Al igual que car, cdr no elimina los elementos de la lista––simplemente devuelve un informe de lo que son el segundo y los elementos siguientes.

A propositio, en el ejemplo, se cita la lista de las flores. De otra forma, el intérprete Lisp intentaría evaluar la lista llamando a rosa como una función. En este ejemplo, no queremos hacer esto.

Claramente, un nombre más razonable para cdr sería rest (resto).

(Hay una lección aquí: Cuando des nombre a nuevas funciones, considera muy cuidadosamente lo que estes haciendo, ya que puedes adherirte a los nombres mas tiempo del esperado. La razón por la que este documento perpetúa estos nombres se debe a que el código fuente de Emacs Lisp los utiliza, y de no usarlos, tendrias dificultades para leer el codigo; por favor, intenta evitar usar estos términos por tu cuenta. Las personas que vengan después te lo agradecerán.

Cuando se aplican car y cdr a una lista compuesta por símbolos, como la lista (pino abeto roble arce), el elemento de la lista devuelto por la función car es el símbolo pino sin ningun paréntesis alrededor. pino es el primer elemento en la lista. Sin embargo, el cdr de la lista es una lista en si misma, (abeto roble arce), como puedes observar al evaluar las siguientes expresiones:

(car '(pino abeto roble arce))

(cdr '(pino abeto roble arce))

Por otro lado, en una lista de listas, el primer elemento es en sí mismo una lista. car devuelve este primer elemento como una lista. Por ejemplo, la siguiente lista contiene tres sub-listas, una lista de carnívoros, una lista de herbívoros y una lista de mamíferos:

(car '((leon tigre leopardo)
       (gacela antilope cebra)
       (ballena delfin foca)))

En este ejemplo, el primer elemento de car de la lista es la lista de carnívoros, (leon tigre leopardo), y el resto de la lista es ((gacela antilope cebra) (ballena delfin foca)).

(cdr '((leon tigre leopardo)
       (gacela antilope cebra)
       (ballena delfin foca)))

vale la pena decir nuevamente que car y cdr son no destructivos––es dicir, no modifican ni cambian las listas a las que se aplican. Esto es muy importante para la forma en que se utilizan.

En el primer capítulo, en la discusión sobre los átomos, dije que en Lisp, “ciertos tipos de átomos, como un arreglo, pueden ser separados en partes; pero el mecanismo para hacer esto es diferente del mecanismo para separar una lista. Para Lisp, los átomos de una lista son indivisibles.” (Consulta la Seccion Átomos Lisp.) Las funciones car y cdr se utilizan para dividir listas y se consideran fundamentales en Lisp. Ya que no se puede dividir o tener acceso a las partes de un arreglo, un arreglo se considera un átomo. Por otro lado, la otra función fundamental, cons, puede armar o construir una lista, pero no un arreglo. (Los arreglos se manejan mediante funciones especificas de arreglos. Consulta la Seccion Arreglos en el El Manual de Referencia de GNU Emacs Lisp.)

La función cons construye listas; que es lo opuesto a car y cdr. Por ejemplo, se puede utilizar cons para hacer una lista de cuatro elementos de la lista de tres elementos, (abeto roble arce):

(cons 'pino '(abeto roble arce))

Después de evaluar esto, veras

(pino abeto roble arce)

aparecer en el área de eco. cons produce una nueva lista en la que el elemento es seguido por los elementos de la lista original.

Con frecuencia decimos que ‘cons coloca un nuevo elemento al principio de una lista; que agrega o empuja el elemento en la lista’, pero esta frase puede ser engañosa, ya que cons no modifica una lista existente, sino que crea una nueva.

Al igual que car y cdr, cons es no destructivo.

cons debe tener una lista a unir.⁹ No puedes iniciar de la nada absoluta. Si estás construyendo una lista, es necesario proporcionar al menos una lista vacía al inicio. Aquí hay una serie de expresiones cons que construyen una lista de flores. Si está leyendo esto en GNU Emacs, puedes evaluar cada una de las expresiones para corroborar el resultado.

> (cons 'tulipan ())
(tulipan)
> (cons 'margarita '(tulipan))
(margarita tulipan)
> (cons 'violeta '(margarita tulipan))
(violeta margarita tulipan)
> (cons 'rosa '(violeta margarita tulipan))
(rosa violeta margarita tulipan)

En el primer ejemplo, la lista vacía se muestra como () y se construye una lista compuesta por tulipan seguida por la lista vacía. Como puedes ver, la lista vacía no se muestra en la lista que se construyo. Todo lo que ves es (tulipan). La lista vacía no cuenta como un elemento de una lista porque no hay nada en una lista vacía. En terminos generales, una lista vacía es invisible.

El segundo ejemplo, (cons 'margarita '(tulipan)) construye una nueva lista de dos elemento colocando margarita delante de tulipan; y el tercer ejemplo construye una lista de tres elementos colocando violeta delante de margarita y tulipan.

Puedes averiguar cuántos elementos hay en una lista utilizando la función Lisp length, como en los siguientes ejemplos:

> (length '(tulipan))
1
> (length '(margarita tulipan))
2
> (length (cons 'violeta '(margarita tulipan)))
3

En el tercer ejemplo, la función cons se utiliza para construir una lista de tres elementos que se pasa como argumento a la función length.

También podemos utilizar length para contar el número de elementos en una lista vacía:

> (length ())
0

Como era de esperar, el número de elementos en una lista vacía es cero.

Un experimento interesante es averiguar qué ocurre si se intenta encontrar la longitud de ninguna lista; es decir, si se intenta llamar a length sin darle un argumento, ni siquiera una lista vacía:

(length )

La que se ve, si evalúas esto, es el mensaje de error

Lisp error: (wrong-number-of-arguments length 0)

Esto significa que la función recibe un número incorrecto de argumentos, cero, cuando se espera otro número de argumentos. En este caso, se espera un argumento, el argumento es una lista cuya longitud mide la función. (Ten en cuenta que una lista es un argumento, incluso si la lista tiene muchos elementos en su interior.)

La parte del mensaje de error que dice ‘length’ es el nombre de la función.

La función nthcdr esta asociada a la función cdr. Lo que hace es tomar el cdr de una lista repetidamente.

Si tomas el cdr de la lista (pino abeto roble arce), te devuelve la lista (abeto roble arce). Si repites esto al retorno, devolverá la lista (roble arce). (Por supuesto, repetir cdr en la lista original solo dará el cdr original, ya que la función no cambia la lista. Necesitas evaluar el cdr del cdr y así sucesivamente.) Si esto contiúa, finalmente se devuelve una lista vacía, que en este caso, en vez de mostrarse como () se muestra como nil.

Para comprobarlo, aquí hay una serie de cdrs repetidos.

> (cdr '(pino abeto roble arce))
(abeto roble arce)
> (cdr '(abeto roble arce))
(roble arce)
> (cdr '(roble arce))
(arce)
> (cdr '(arce))
nil
> (cdr 'nil)
nil
> (cdr ())
nil

También puedes hacer varios cdrs sin imprimir los valores intermedios, de esta forma:

> (cdr (cdr '(pino abeto roble arce)))
(roble arce)

En este ejemplo, el intérprete Lisp primero evalúa la lista mas interna. La lista mas interna se cita, por lo que solo pasa la lista tal cual al cdr interno. Este cdr pasa una lista formada por el segundo y los subsiguientes elementos de la lista al cdr externo, que produce una lista compuesta del tercer y los subsiguientes elementos de la lista original. En este ejemplo, la función cdr se repite y devuelve una lista que consiste en la lista original sin sus primeros dos elementos.

La función nthcdr hace lo mismo que repetir la llamada a cdr. En el siguiente ejemplo, el argumento 2 se pasa a la función nthcdr, junto con la lista, y el valor devuelto es la lista sin sus dos primeros elementos, que es exactamente lo mismo que repetir dos veces cdr en la lista:

> (nthcdr 2 '(pino abeto roble arce))
(roble arce)

Utilizando la lista original de cuatro elementos, podemos ver qué ocurre cuando se pasan varios argumentos numéricos a nthcdr, incluyendo 0, 1, y 5:

> ;; Deja la lista como estaba.
> (nthcdr 0 '(pino abeto roble arce))
(pino abeto roble arce)
> ;; Regresa una copia sin el primer elemento.
> (nthcdr 1 '(pino abeto roble arce))
(abeto roble arce)
> ;; Regresa una copia de la lista sin tres elementos.
> (nthcdr 3 '(pino abeto roble arce))
(arce)
> ;; Regresa una copia sin los cuatro elementos.
> (nthcdr 4 '(pino abeto roble arce))
nil
> ;; Regresa una copia sin todos los elementos.
> (nthcdr 5 '(pino abeto roble arce))
nil

La función nthcdr toma el cdr de una lista repetidamente. La función nth toma el car del resultado devuelto por nthcdr. Devuelve el enesimo elemento de la lista.

Por lo tanto, si nth no estubiera definido en C por velocidad, su definición sería:

(defun nth (n list)
  "Devuelve el N-esimo elemento de la lista.
N cuenta apartir de cero. Si LIST no es tan largo, devuelve nil."
  (car (nthcdr n list)))

(Originalmente, nth se definio en Emacs Lisp dentro de subr.el, pero su definición fué rehecha en C en la decada de 1980.)

La función nth devuelve un solo elemento de una lista. Esto puede ser muy conveniente.

Observa que los elementos estan numerados apartir del cero, no de uno. Es decir, el primer elemento de una lista, su car es el elemento cero. Esto se llama contar ‘basado en cero’ y con frecuencia molesta a las personas que estan acostumbradas a que el primer elemento de una lista sea el número uno, que es ‘basado en uno’.

Por ejemplo:

> (nth 0 '("uno" "dos" "tres"))
"uno"
> (nth 1 '("uno" "dos" "tres"))
"dos"

Vale la pena mencionar que nth, al igual que nthcdr y cdr, no modifica la lista original––la función es no destructiva. Esto contrasta fuertemente con las funciones setcar y setcdr.

Como podrías adivinar por sus nombres, las funciones setcar y setcdr establecen el car o el cdr de una lista a un nuevo valor. Ambos cambian realmente la lista original, a diferencia de car y cdr que dejan la lista original como estaba. Una forma de averiguar cómo funcionan es experimentar. Vamos a empezar con la función setcar.

Primero, podemos crear una lista y luego asignar el valor de una variable a la lista, usando la función setq. Aquí hay una lista de animales:

(setq animales '(antilope jirafa leon tigre))

Si estás leyendo esto dentro de GNU Emacs, puedes evaluar esta expresión de la forma habitual, coloca el cursor después de la expresión y presiona C-x C-e. (Estoy haciendo esto aqui mismo, mientras lo escribo. Esta es una de las ventajas de tener el intérprete construido dentro del entorno informatico. Por cierto, cuando no hay nada en la línea después del paréntesis final, como un comentario, el punto puede estar en la siguiente línea. De este modo, si tu cursor está en la primera columna de la siguiente línea, no es necesario moverlo. En realidad, Emacs permite cualquier cantidad de espacios en blanco después del paréntesis final.)

Cuando evaluamos la variable animales, vemos que está unida a la lista (antilope jirafa leon tigre):

> animales
(antilope jirafa leon tigre)

Dicho de otro modo, la variable animales apunta a la lista (antilope jirafa leon tigre).

A continuacion, evalua la función setcar mientras le pasas dos argumentos, la variable animales y el símbolo citado hipopotamo; esto se hace escribiendo una lista de tres elementos (setcar animales 'hipopotamo). Evaluala de la forma habitual:

(setcar animales 'hipopotamo)

Después de evaluar esta expresión, evalúa la variable animales de nuevo. Veras que la lista de animales ha cambiado:

> animales
(hipopótamo jirafa leon tigre)

El primer elemento de la lista, antilope fue reemplazado por hipopotamo.

Así podemos ver que setcar no agrega un nuevo elemento a la lista como haria cons; Se reemplaza antílope con hipopótamo; esto cambia la lista.

La función setcdr es similar a la función setcar, excepto que la función reemplaza el segundo y subsiguientes elementos de una lista en lugar del primer elemento.

(Para ver cómo cambiar el último elemento de una lista, mira directamente en la Seccion La función kill-new, que utiliza las funciones nthcdr y setcdr.)

Para ver cómo funciona esto, asigna el valor de la variable a una lista de animales domesticados evaluando la siguiente expresión:

(setq animales-domesticados '(caballo vaca oveja cabra))

Si evalúas la lista, debe devolverte la lista (caballo vaca oveja cabra):

> animales-domesticados
(caballo vaca oveja cabra)

Luego, evalúa setcdr con dos argumentos, el nombre de la variable que tiene una lista como su valor, y la lista a la que se establecera el cdr de la primera lista;

(setcdr animales-domesticados '(gato perro))

Si evalúas esta expresión, la lista (gato perro) aparecerá en el área echo. Este es el valor devuelto por la función. El resultado que nos interesa es el “efecto secundario”, que podemos ver evaluando la variable animales-domesticados:

> animales-domesticados
(caballo gato perro)

En efecto, la lista cambia de (caballo vaca oveja cabra) a (caballo gato perro). El cdr de la lista cambia de (vaca oveja cabra) a (gato perro).

Construye una lista de cuatro pájaros evaluando varias expresiones con cons. Descubre que ocurre cuando aplicas cons a una lista sobre si misma. Reemplaza el primer elemento de la lista de cuatro pájaros con un pez. Reemplaza el resto de esta lista con una lista de otros peces.

Cada vez que se corta texto de un búfer con un comando ‘kill’, se almacena en una lista y puedes traerlo de vuelta con un comando ‘yank’.

(El uso de la palabra ‘kill’ (matar) en Emacs para procesos que específicamente no destruyen los valores de las entidades es un accidente histórico desafortunado. Una palabra mucho más apropiada seria ‘clip’ (recortar) ya que eso es lo que hacen los comandos ‘kill’; recortan el texto de un búfer y lo almacenan para que puede traerse de vuelta. Con frecuencia me he sentido tentado a sustituir globalmente todas las apariciones de ‘kill’ en el codigo de Emacs con ‘clip’ y todas las apariciones de ‘killed’ (destruido) con ‘clipped’ (cortado).)

Cuando el texto se corta de un búfer, se almacena en una lista. Los fragmentos de texto se almacenan en la lista de forma sucesiva, por lo que la lista podría verse así:

("una pieza de texto" "pieza anterior")

La función cons se puede utilizar para crear una nueva lista a partir de un trozo de texto (un ‘átomo’, para usar la jerga) y una lista existente, como esta:

(cons "otra pieza"
      '("una pieza de texto" "pieza anterior"))

Si evaluas esta expresión, aparecera una lista de tres elementos en el área de eco:

("otra pieza" "una pieza de texto" "pieza anterior")

Puedes recuperar cualquier pieza de texto que desees, con las funciones car y nthcdr. Por ejemplo, en el siguiente código, nthcdr 1 … devuelve la lista con el primer elemento eliminado; y car devuelve el primer elemento de ese resto––el segundo elemento de la lista original:

> (car (nthcdr 1 '("otra pieza"
                 "una pieza de texto"
                 "pieza anterior")))
"una pieza de texto"

Por supuesto, las funciones reales en Emacs son más complejas que esto. El código para el corte y recuperarcion de texto tiene que ser escrito de modo que Emacs pueda determinar qué elemento en la lista se quiere––el primero, segundo, tercero o cualquier otro. Además, cuando se llega al final de la lista, Emacs deberia darte el primer elemento de la lista, en lugar de nada en absoluto.

La lista que contiene los trozos de texto se llama kill ring (anillo de la muerte). En este capítulo se hace una descripción del anillo de la muerte y como se utiliza en un primer vistazo a la función zap-to-char. Esta función utiliza (o ‘llama’) a una función que invoca a otra función que manipula el anillo de la muerte. Por la tanto, antes de llegar a las montañas, debemos escalar las colinas.

En un capítulo posterior se describe cómo se recupera el texto que se corta de un buffer. Consulta la Sección Traer de regreso el texto.

La función zap-to-char apenas ha variado entre la versión 19 y 22 de GNU Emacs. Sin embargo, zap-to-char llama a otra función, kill-region, que ha tenido una importante reescritura.

La función kill-region en Emacs 19 es compleja, pero no utiliza código que sea importante en este momento. Nos Lo saltaremos.

La función kill-region en Emacs 22 es más fácil de leer que la misma función en Emacs 19 e introduce un concepto muy importante, la gestion de errores. Caminaremos a través de la función.

Pero primero, veamos la función interactiva zap-to-char.

La función zap-to-char elimina el texto en la región entre la ubicacion del cursor (es decir, del punto) hasta e incluyendo la siguiente aparicion de un caracter específicado. El texto que zap-to-char elimina se pone en el anillo de la muerte; y se puede recuperar escribiendo C-y (yank). Si el comando recive un argumento, elimina el texto a través de ese número de ocurrencias. Por lo tanto, si el cursor estuviera al inicio de esta frase y el carácter fuera ‘s’, se eliminaria ‘Por lo tanto, s’. Si el argumento fuera dos, se eliminaria ‘Por lo tanto, si el curs’, hasta e incluiendo la ‘s’ en ‘cursor’.

Si no se encuentra el carácter específicado zap-to-char dirá “Search failed” (Búsqueda fallida), te indicaria el caracter que escribiste, y no eliminara ningun texto.

Para determinar la cantidad de texto a eliminar zap-to-char utiliza una función de búsqueda. Las búsquedas se utilizan ampliamente en código que manipula el texto, y vamos a centrar la atención en ellos, asi como en el comando de eliminacion.

Aquí está el texto completo de la función en la versión 22:

(defun zap-to-char (arg char)
  "Corta e incluye la aparicion de la enesima ocurrencia (ARG) del caracter CHAR.
Se ignora entre mayusculas y minusculas si ‘case-fold-search’ es no-nil en
el buffer actual.
Retrocede si ARG es negativo; error si CHAR no se encuentra."
  (interactive "p\ncZap to char: ")
  (if (char-table-p translation-table-for-input)
      (setq char (or (aref translation-table-for-input char) char)))
  (kill-region (point) (progn
                         (search-forward (char-to-string char) nil nil arg)
                         (point))))

La linea de documentacion esta traducida al español. En la version original no se utiliza la palabra ‘Corta’ en su lugar se utiliza ‘kill’.

La expresión interactiva en el comando zap-to-char es esta:

(interactive "p\ncZap to char: ")

La parte entre comillas, "p\ncZap to char: ", especifica dos cosas diferentes. Primero, y lo mas sencillo, es la ‘p’. Esta parte se separa de la siguiente parte por una línea nueva, ‘\n’. La ‘p’ significa que a el primer argumento de la función será pasando el valor de un ‘prefijo procesado’. El argumento prefijo se pasa escribiendo C-u y un número, o M- y un número. Si la función se llamada interactivamente sin un prefijo, se pasa 1 a este argumento.

La segunda parte de "p\ncZap to char: " es ‘cZap to char:’. En esta parte, la ‘c’ minuscula indica que interactive espera un prompt y que el argumento será un caracter. El prompt va despues de ‘c’ y es la cadena ‘Zap to char: ’ (con un espacio después de los dos puntos para que se vea bien).

Lo que todo esto hace es preparar los argumentos de zap-to-char para que sean del tipo correcto, y darle al usuario un prompt.

En un búfer de solo lectura, la función zap-to-char copia el texto al anillo de la muerte, pero no lo elimina. El área de eco muestra un mensaje diciendo que el búfer es de solo lectura. Ademas, el terminal puede emitir un pitido o parpadear.

El cuerpo de la función zap-to-char contiene el código que mata (es decir, elimina) el texto en la región desde la posición actual del cursor hasta e incluyendo el carácter especificado.

La primera parte del código luce asi:

(if (char-table-p translation-table-for-input)
    (setq char (or (aref translation-table-for-input char) char)))
(kill-region (point) (progn
                       (search-forward (char-to-string char) nil nil arg)
                       (point)))

char-table-p es una función que aun no hemos visto. Determina si su argumento es una tabla de caracteres. Si lo es, establece el caracter pasado a zap-to-char a uno de ellos, si ese carácter existe, o al carácter en sí. (Esto es importante para ciertos caracteres en idiomas no europeos. La función aref extrae un elemento desde un arreglo. Esta funcion es específica para arreglos y no sera descrita en este documento. Consulta la Seccion Arreglos en El Manual de Referencia de GNU Emacs Lisp.)

(point) es la posición actual del cursor.

La siguiente parte del código es una expresión utilizando progn. El cuerpo de progn consiste en llamadas a search-forward y point.

Es fácil comprender cómo funciona progn después de aprender sobre search-forward, asi que veremos search-forward y luego progn.

La función search-forward se utiliza para localizar el caracter a borrar en zap-to-char. Si la búsqueda es exitosa, search-forward deja el punto inmediatamente después del último carácter en la cadena objetivo. (En zap-to-char, la cadena objetivo tiene solo un carácter longitud. zap-to-char usa la función char-to-string para asegurar que el computador trata este carácter como una cadena). Si la búsqueda es hacia atrás, search-forward deja el punto justo antes del primer carácter en el objetivo. Ademas, search-forward devuelve t para verdadero. (Por lo tanto, desplazar el punto es un ‘efecto secundario’.)

En zap-to-char, la función search-forward se ve así:

(search-forward (char-to-string char) nil nil arg)

La función search-forward utiliza cuatro argumentos:

1. El primer argumento es el objetivo, que esta buscando. Debe ser una cadena, como "z".

   Sucede que el argumento pasado a zap-to-char es un solo caracter. Debido a la forma en la que se construyen los computadores, el intérprete Lisp puede tratar un solo caracter de forma distinta a una cadena de caracteres. Dentro del computador, un solo caracter tiene un formato electrónico diferente a una cadena de un caracteres. (Un solo caracter con frecuencia puede grabarse en el computador utilizardo exactamente un byte; pero una cadena puede ser mas larga, y el equipo debe estar listo para ello.) Ya que la función search-forward busca una cadena, el caracter que recive la función zap-to-char como argumento debe convertirse dentro del computador de un formato a otro; de lo contrario, la función search-forward fallará. Se utiliza la función char-to-string para realizar esta conversión.

2. El segundo argumento limita la búsqueda; se especifica como una posición en el búfer. En este caso, la búsqueda puede ir al final del búfer, por lo que no se establece ningun limite y el segundo argumento es nil.

3. El tercer argumento le dice a la función lo que debe hacer si la búsqueda falla––puede señalar un error (e imprimir un mensaje) o puede devolver nil. Un nil como el tercer argumento hace que la función señale un error cuando la búsqueda falla.

4. El cuarto argumento de search-forward es el contador de repeticion––cuántas ocurrencias de la cadena hay que buscar. Este argumento es opcional y si la función se llamada sin contador de repeticion, este argumento pasa el valor 1. Si este argumento es negativo, la búsqueda va hacia atrás.

En formato plantilla, una expresión search-forward tiene este aspecto:

(search-forward "cadena-a-buscar"
                limite-de-busqueda
                que-hacer-si-la-busqueda-falla
                contador-de-repeticion)

A continuacion veremos progn.

progn es una forma especial que hace que cada uno de sus argumentos sea evaluado en secuencia y luego devuelve el valor del último. Las expresiones anteriores solo se evaluan por los efectos secundarios que producen. Los valores producidos son descartados.

La plantilla de una expresión progn es muy simple:

(progn
  cuerpo…)

En zap-to-char, la expresión progn tiene que hacer dos cosas: poner el punto exactamente en la posición correcta; y devolver la posición del punto para que kill-region sepa hasta donde cortar.

El primer argumento de progn es search-forward. Cuando search-forward encuentra la cadena, la función deja el punto inmediatamente después del último caracter en la cadena objetivo. (En este caso la cadena objetivo tiene solo un carácter de longitud.) Si la búsqueda es hacia atrás, search-forward deja el punto justo antes del primer carácter objetivo. El movimiento del punto es un efecto secundario.

El segundo y último argumento de progn es la expresión (point). Esta expresión devuelve el valor del punto, que en este caso será la ubicacion a la que se ha desplazado por search-forward. (En el codigo, una línea le indicaba a la función que debia ir un carácter atras, si va hacia adelante, se comentó en 1999; yo no recuerdo si esta caracteriscita o funcion incorrecta alguna vez fue parte del codigo distribuido.) El valor de point es devuelto por la expresión progn y se pasa a kill-region como el segundo argumento de kill-region .

Ahora que hemos visto cómo funcionan search-forward y progn, podemos ver cómo la función zap-to-como trabaja como un todo.

El primer argumento de kill-region es la posición del cursor cuando se da el comando zap-to-char––el valor de punto en ese momento. Dentro de progn, la funcion de búsqueda mueve el punto justo después del caracter a borrar y point devuelve el valor de esa ubicacion. La función kill-region reune estos dos valores de punto, el primero como el inicio de la región y el segundo como el final de la región, y elimina la región.

La forma especial progn es necesaria porque el comando kill-region toma dos argumentos; y fallaría si las expresiones search-forward y point se escribieran en secuencia como dos argumentos adicionales. La expresión progn es solo un argumento para kill-region y devuelve el valor que kill-region necesita para su segundo argumento.

La función zap-to-char utiliza la función kill-region. Esta función corta texto de una región y copia ese texto al anillo de la muerte, desde el que puede ser recuperado.

La versión en Emacs 22 de esta funcion utiliza condition-case y copy-region-as-kill, ambas seran explicadas. condition-case es una forma especial importante.

En esencia, la función kill-region llama a condition-case, que toma tres argumentos. En esta función, el primer argumento no hace nada. El segundo argumento contiene el código que hace el trabajo cuando todo va bien. El tercer argumento contiene el código que se llama en caso de error.

Revisaremos el código de condition-case en un momento. Primero, veamos la definición de kill-region, con comentarios añadidos:

(defun kill-region (beg end)
  "Kill (\"corta\") el texto entre el punto y la marca.
Esto elimina el texto del buffer y lo guarda en el anillo de la muerte.
El comando \\[yank] puede recuperarlo desde alli. … "

  ;; • Puesto que el orden importa, primero pasa el punto.
  (interactive (list (point) (mark)))
  ;; • Y dinos si no podemos cortar el texto.
  ;; ‘unless’ es un ‘if’ sin parte-then.
  (unless (and beg end)
    (error "La marca no esta definida, asi que no hay ninguna region"))
  ;; • ‘condition-case’ toma tres argumentos.
  ;;    Si el primer argumento es nil, como aqui,
  ;;    la informacion del error no se almacena
  ;;    para ser utilizado por otra funcion.
  (condition-case nil

      ;; • El segundo argumento de ‘condition-case’ le dice al
      ;;    interprete Lisp que hacer cuando todo va bien.

      ;;    Empieza con una funcion ‘let’ que extrae la cadena y
      ;;    comprueba si existe. Si es asi (eso es lo que comprueba
      ;;    ‘when’), esta llama a una funcion ‘if’ que determina
      ;;    si el comando anterior fue otra llamada a ‘kill-region’;
      ;;    si lo fue, el nuevo texto se añade al texto anterior; si
      ;;    no, se llama a una funcion diferente, se llama a ‘kill-new’.

      ;;    La funcion ‘kill-append’ concatena la cadena nueva y antigua.
      ;;    La funcion ‘kill-new’ inserta el texto dentro de un nuevo
      ;;    elemento en el anillo de la muerte.

      ;;    ‘when’ es un ‘if’ sin una parte-else. El segundo ‘when’
      ;;    comprueba de nuevo si la cadena actual existe; Ademas,
      ;;    comprueba si el comando anterior fue otra llamada a
      ;;    ‘kill-region’. Si una u otra condicion es verdadera,
      ;;    entonces establece que el comando actual sea ‘kill-region’.
      (let ((string (filter-buffer-substring beg end t)))
        (when string                    ;STRING es nil si BEG = END
          ;; agrega esa cadena al anillo de la muerte, de uno forma u otra.
          (if (eq last-command 'kill-region)
              ;;    − ‘yank-handler’ es un argumento opcional de
              ;;    ‘kill-region’ que indica a las funciones ‘kill-append’
              ;;    y ‘kill-new’ como tratar las propiedades añadidas al
              ;;    texto, como ‘negrita’ o ‘cursiva’.
              (kill-append string (< end beg) yank-handler)
            (kill-new string nil yank-handler)))
        (when (or string (eq last-command 'kill-region))
          (setq this-command 'kill-region))
        nil)

    ;;  • El tercer argumento de ‘condition-case’ le dice al interprete
    ;;    que hacer con un error.
    ;;    El tercer argumento tiene una parte de condiciones y una parte cuerpo.
    ;;    Si se cumplen las condiciones (en este caso,
    ;;             si el texto o el buffer son de solo lectura)
    ;;    entonces se ejecuta el cuerpo.
    ;;    La primer parte del tercer argumento es la siguiente:
    ((buffer-read-only text-read-only) ;; la parte-if
     ;; …  la parte-then
     (copy-region-as-kill beg end)
     ;;    A continuacion, tambien como parte de la parte-then, establece
     ;;    this-command, por lo que se establece en un error
     (setq this-command 'kill-region)
     ;;    Finalmente, en la pante-then, envia un mensaje si puede copiar
     ;;    el texto en el anillo de la muerte sin señalar un error, pero
     ;;    no lo hace si no puede.
     (if kill-read-only-ok
         (progn (message "Read only text copied to kill ring") nil)
       (barf-if-buffer-read-only)
       ;; Si el buffer no es de solo lectura, el texto lo es.
       (signal 'text-read-only (list (current-buffer)))))

Como se ha visto antes (Consulta la Seccion Generar un Mensaje de Error), cuando el intérprete de Emacs Lisp tiene problemas evaluando una expresión, te proporciona ayuda; en la jerga, esto se llama “Señalar un error”. Normalmente, el computador detiene el programa y te muestra un mensaje.

Sin embargo, algunos programas emprenden acciones complicadas. No deberian simplemente detenerse en un error. En la función kill-region, el error mas probable es que intente cortar texto que sea de solo lectura y no pueda ser eliminado. Así que la función kill-region contiene código para manejar esta circunstancia. Este código, que forma el cuerpo de la función kill-region, se encuentra dentro de una forma especial condition-case.

La plantilla para condition-case tiene este aspecto:

(condition-case
  var
  bodyform
  gestor-de-errores…)

El segundo argumento, bodyform es sencillo. La forma especial condition-case hace que el intérprete Lisp evalúe el código en bodyform. Si no ocurre ningún error, la forma especial devuelve el valor del código y produce los efectos secundarios, si los hubiera.

En resumen, la parte bodyform de una expresión condition-case determina qué deberia suceder cuando todo funciona correctamente.

Sin embargo, si ocurre un error, entre otras acciones, la función genera la señal de error que define uno o más nombres de condicion de error.

El gestor de errores es el tercer argumento de condition-case. Un gestor de errores tiene dos partes, un nombre-de-condicion y un cuerpo. Si la parte nombre-de-condicion de un gestor de errores coincide con un nombre de condicion generado por un error, se ejecuta la parte del cuerpo del gestor de errores.

Como es de esperar, la parte nombre-de-condicion de un gestor de errores puede ser un unico nombre de condicion o una lista de nombres de condición.

Ademas, una expresión condition-case completa puede contener más de un gestor de errores. Cuando se produce un error, se ejecuta el primer gestor aplicable.

Por ultimo, el primer argumento de la expresión condition-case, el argumento var, en ocaciones se vincula a una variable que contiene información sobre el error. Sin embargo, si este argumento es nil, como es el caso en kill-region, esa información se descarta.

En resumen, en la función kill-region, el código condition-case funciona de la siguiente manera:

Si no hay errores, ejecuta solo este codigo
    pero, si hay errores, ejecuta este otro codigo.

La parte de la expresión condition-case se evalúa con la expectativa de que todo va bien si tiene un when. El código utiliza when para determinar si la variable string apunta a texto que existe.

Una expresión when simplemente es una conveniencia para los programadores. Es un if sin la posibilidad de una cláusula else. En tu mente, puedes reemplazar when con if y entender lo que pasa. Eso es lo que hace el intérprete Lisp.

Técnicamente hablando, when es una macro Lisp. Una macro Lisp te permite definir nuevas construcciones de control y otras caracteristicas de lenguaje. Le indica al intérprete cómo calcular otra expresión Lisp que a su vez calculara el valor. En este caso, la ‘otra expresión’ es una expresión if.

La definición de la función kill-region también tiene una macro unless; es lo contario de when. La macro unless es un if sin la cláusula then.

Para optener más informacion sobre las macros Lisp, consulta la Seccion Macros en El Manual de Referencia de Emacs Lisp. El lenguaje de programación C también proporciona macros. Estos son diferentes, pero también útiles.

Respecto a la macro when, en la expresión condition-case, cuando la cadena tiene contenido, se ejecuta otra expresión condicional. Esto es un if tanto con la parte-then como con la parte-else.

(if (eq last-command 'kill-region)
    (kill-append string (< end beg) yank-handler)
  (kill-new string nil yank-handler))

La parte-then se evalúa si el comando anterior era otra llamada a kill-region; si no, se evalúa la parte-else.

yank-handler es un argumento opcional de kill-region que indica a las funciones kill-append y kill-new como tratar con propiedades añadidas al texto, como ‘negrilla’ o ‘cursiva’.

last-command es una variable que viene con Emacs y que no hemos visto antes. Normalmente, siempre que se ejecuta una función, Emacs establece el valor de last-command al comando anterior.

En este segmento de la definición, la expresión if comprueba si el comando anterior fue kill-region. Si lo fuera,

(kill-append string (< end beg) yank-handler)

concatena una copia del texto recien cortado al texto cortado previamente en el anillo de la muerte.

La función copy-region-as-kill copia una región de texto de un búfer y (via kill-append o kill-new) lo guarda en el kill-ring.

Si llamas a copy-region-as-kill inmediatamente después de un comando kill-region, Emacs agregara el texto recien copiado al texto copiado previamente. Esto significa que traes el texto, lo obtienes todo, tanto de esta operacion como de la anterior. Por otra parte, si algún otro comando precede a copy-region-as-kill, la función copia el texto dentro de una entrada separada en el anillo de la muerte.

Aquí está el texto completo de la función copy-region-as-kill de la versión 22:

(defun copy-region-as-kill (beg end)
  "Guarda la region como si fuese cortada, pero no la corta.
En el modo Transient Mark, desactiva la marca.
Si ‘interprogram-cut-function’ es no-nil, tambien guarda el texto para un
sistema de ventana cortar y pegar."
  (interactive "r")
  (if (eq last-command 'kill-region)
      (kill-append (filter-buffer-substring beg end) (< end beg))
    (kill-new (filter-buffer-substring beg end)))
  (if transient-mark-mode
      (setq deactivate-mark t))
  nil)

Como de costumbre, esta función puede dividirse en las partes que la componen:

(defun copy-region-as-kill (lista-de-argumentos)
  "documentacion…"
  (interactive "r")
  cuerpo…)

Los argumentos son beg y end y la función es interactiva con "r", por lo que los dos argumentos deben referirse al inicio y al final de la región. Si has estado leyendo este documento desde el principio, entender estas partes de una función se esta convirtiendo en algo rutinario.

En la documentación, los comentarios de ‘Transient Mark’ e interprogram-cut-function explican ciertos efectos secundarios.

Después de establecer una marca, un búfer siempre contiene una región. Si lo deseas puedes utilizar el modo Transient Mark para resaltar temporalmente la región. (Nadie quiere resaltar la región todo el tiempo, por lo que el modo Trasient Mark lo resalta solo en los momentos apropiados. Muchas personas desactivan el modo Transient Mark, por lo que la región nunca se resalta.)

Ademas, un sistema de ventanas permite copiar, cortar y pegar entre diferentes programas. En el sistema de ventanas X, por ejemplo, la función interprogram-cut-function es x-select-text, que funciona con el sistema de ventanas equivalente al anillo de la muerte de Emacs.

El cuerpo de la función copy-region-as-kill inicia con una cláusula if. Lo que esta cláusula hace es distinguir entre dos situaciones diferentes: si este comando se ejecuta o no inmediatamente después de un comando kill-region anterior. En el primer caso, la nueva región se concatena al texto copiado previamente. De lo contrario, se inserta al inicio del anillo de la muerte como una pieza de texto separada de la anterior.

Las dos ultimas líneas de la función impiden que la región se ilumine si el modo Transient Mark está activo.

El cuerpo de copy-region-as-kill merece ser discutido en detalle.

copy-region-as-kill funciona de un modo parecido a la función kill-region. Ambas están escritas de manera que dos o más cortes en una fila combinan su texto en una sola entrada. Si sacas el texto del anillo de la muerte, se optiene todo en una sola pieza. Ademas, las funciones que cortan hacia adelante desde la posición actual del cursor se añaden al final del texto copiado previamente y los comandos que cortan el texto hacia atrás lo añaden al principio del texto copiado previamente. De esta manera, las palabras del texto permanecen en el orden correcto.

Al igual que kill-region, la función copy-region-as-kill hace uso de la variable last-command que mantiene un seguimiento del comando Emacs anterior.

Normalmente, siempre que se ejecuta una función, Emacs asigna el valor de this-command a la función que se esta ejecutando (que en este caso sería copy-region-as-kill). Al mismo tiempo, Emacs asigna el valor de last-command al valor anterior de this-command.

En la primer parte del cuerpo de la función copy-region-as-kill, una expresión if determina si el valor de last-command es kill-region. Si es así, se evalua la parte-then de la expresión if; utiliza la función kill-append para concatenar el texto copiado en la llamada a esta función con el texto que ya esta en el primer elemento (el car del anillo de la muerte. Por otro lado, si el valor de last-command no es kill-region, entonces la función copy-region-as-kill asigna un nuevo elemento al anillo de la muerte usando la función kill-new.

La expresión if se lee de la siguiente manera; utiliza eq:

(if (eq last-command 'kill-region)
    ;; parte-then
    (kill-append  (filter-buffer-substring beg end) (< end beg))
  ;; parte-else
  (kill-new  (filter-buffer-substring beg end)))

(La función filter-buffer-substring devuelve una subcadena filtrada del búfer, si existe. Opcionalmente––los argumentos no están aquí, por lo que tampoco se hace––la función puede borrar el texto inicial o devolver el texto sin sus propiedades; esta función es un reemplazo para la antigua función buffer-substring, que existia antes de que se implementaran las propiedades del texto.)

La función eq comprueba si su primer argumento es el mismo objeto Lisp que su segundo argumento. La función eq es similar a la función equal que se utiliza para probar la igualdad, pero difiere en que determina si dos representaciones son realmente el mismo objeto dentro de la computadora, pero con nombres diferentes. equal determina si la estructura y el contenido de dos expresiones son iguales.

Si el comando anterior fue kill-region, entonces el intérprete Emacs Lisp llama a la función kill-append

La función kill-new se ve así:

(defun kill-append (string before-p &optional yank-handler)
  "Inserta STRING al fin del ultimo corte en el anillo de la muerte.
Si BEFORE-P no es nil, anexa STRING al corte.
… "
  (let* ((cur (car kill-ring)))
    (kill-new (if before-p (concat string cur) (concat cur string))
              (or (= (length cur) 0)
                  (equal yank-handler
                         (get-text-property 0 'yank-handler cur)))
              yank-handler)))

La función kill-append es bastante sencilla. Utiliza la función kill-new, que discutiremos con más detalle en un momento.

(Ademas, la función proporciona un argumento opcional llamado yank-handler; cuando se invoca, este argumento le dice a la función cómo tratar con la propiedades añadidas al texto, como ‘negrita’ o ‘cursiva’.)

Tiene una función let* para asignar el valor del primer elemento del anillo de la muerte a cur. (No se por qué la función no utiliza let en su lugar; solo un valor se asigna en la expresión. ¿Tal vez este es un bug que no produce problemas?

Examinemos el condicional proporciana uno de los dos argumentos de kill-new. Utiliza concat para concatenar el nuevo texto al car del anillo de la muerte. Si agrega el texto antes o despues depende del resultado de la expresión if:

(if before-p                            ; parte-if
    (concat string cur)                 ; parte-then
  (concat cur string))                  ; parte-else

Si la región a cortar está antes de la región que se cortó en el último comando, entonces debería ser puesta antes que el material guardado en el corte anterior; y, a la inversa, si el texto que se corto esta despues del que se acaba de cortar, debe añadirse después del texto anterior. La expresión if depende del predicado before-p para decidir si el texto recien guardado debe colocarse antes o después del texto anterior.

El símbolo before-p es el nombre de uno de los argumentos para kill-append. Cuando se evalúa la función kill-append, se asocia al valor devuelto evaluando el argumento actual. En este caso, esta es la expresión (< end beg). Esta expresión no determina directamente si el texto cortado en este comando se localiza antes o después del texto cortado del último comando; lo que hace es determinar si el valor de la variable end es menor que el valor de la variable beg. Si es así, significa que problamemente el usuario se dirige hacia el principio del búfer. Ademas, el resultado de evaluar la expresión del predicado. (< end beg), será verdadero y el texto se concatena antes del texto anterior. Por otro lado, si el valor de la variable end es mayor que el valor del la variable beg, el texto se agregara después del texto anterior.

Cuando el texto recien guardado se antepone, la cadena con el nuevo texto se concatena antes que el texto anterior:

(concat string cur)

Pero si el texto será añadido, será concatenado después del texto anterior:

(concat cur string))

Para entender cómo funciona esto, primero necesitamos revisar la función concat. La función concat enlaza o une dos cadenas de texto. El resultado es una cadena. Por ejemplo:

> (concat "abc" "def")
"abcdef"
> (concat "nuevo "
        (car '("primer elemento" "segundo elemento")))
"nuevo primer elemento"
> (concat (car
        '("primer elemento" "segundo elemento")) " modificado")
"primer elemento modificado"

Ahora podemos dar sentido a kill-append: modifica el contenido del anillo de la muerte. El anillo de la muerte es una lista, en la que cada elemento almacena texto. La función kill-append usa la función kill-new que a su vez utiliza la función setcar.

La función kill-new se ve asi:

(defun kill-new (string &optional replace yank-handler)
  "Hace que STRING sea el último corte en el anillo de la muerte.
Establece ‘kill-ring-yank-pointer’ para apuntar a el.

Si ‘interprogram-cut-function’ es no nulo, aplícarlo a STRING.
El segundo argumento opcional REPLACE no-nulo significa que STRING
 reemplazará el frente del kill ring, en lugar de agregarse a la lista.
…"
  (if (> (length string) 0)
      (if yank-handler
          (put-text-property 0 (length string)
                             'yank-handler yank-handler string))
    (if yank-handler
        (signal 'args-out-of-range
                (list string "yank-handler specified for empty string"))))
  (if (fboundp 'menu-bar-update-yank-menu)
      (menu-bar-update-yank-menu string (and replace (car kill-ring))))
  (if (and replace kill-ring)
      (setcar kill-ring string)
    (push string kill-ring)
    (if (> (length kill-ring) kill-ring-max)
        (setcdr (nthcdr (1- kill-ring-max) kill-ring) nil)))
  (setq kill-ring-yank-pointer kill-ring)
  (if interprogram-cut-function
      (funcall interprogram-cut-function string (not replace))))

(Observa que la función no es interactiva.)

Como de costumbre, podemos ver esta función en partes.

La definición de función tiene un argumento opcional yank-handler, que cuando se invoca le dice a la función cómo manejar las propiedades añadidas al texto, tales como ‘negrita’ o ‘cursiva’. Nos Saltaremos eso.

La primer línea de la documentación tiene sentido:

Hace que STRING sea el último corte en el anillo de la muerte.

Vamos a saltarnos el resto de la documentación por el momento.

También, vamos a saltar la expresión if inicial y las líneas de código en menu-bar-update-yank-menu. Las explicaremos mas tarde.

Las líneas críticas son estas:

  (if (and replace kill-ring)
      ;; entonces
      (setcar kill-ring string)
    ;; de otra forma
  (push string kill-ring)
    (setq kill-ring (cons string kill-ring))
    (if (> (length kill-ring) kill-ring-max)
        ;; evita desbordar el anillo de la muerte
        (setcdr (nthcdr (1- kill-ring-max) kill-ring) nil)))
  (setq kill-ring-yank-pointer kill-ring)
  (if interprogram-cut-function
      (funcall interprogram-cut-function string (not replace))))

La prueba condicional es (and replace kill-ring). Esto será verdadero cuando se cumplan dos condiciones: el anillo de la muerte tiene algo en el, y la variable replace es verdadera.

Cuando la función kill-append establece replace como verdadero y cuando el anillo de la muerte tiene al menos un elemento en el, se ejecuta la expresión setcar.

(setcar kill-ring string)

La función setcar realmente cambia el primer elemento de la lista kill-ring al valor de string. Eso reemplaza el primer elemento.

Por otro lado, si el anillo de la muerte está vacío, o replace es falso, se ejecuta la parte-else de la condición:

(push string kill-ring)

push pone su primer argumento dentro del segundo. Es similar a la mas antigua

(setq kill-ring (cons string kill-ring))

o la mas reciente

(add-to-list kill-ring string)

Cuando es falso, la expresión primero construye una nueva versión del anillo de la muerte, añadiendo string al anillo como un nuevo elemento (que es lo que hace push). Entonces ejecuta una segunda clausula if. Este segundo if impide que el anillo de la muerte se haga demaciado largo.

Veamos estas dos expresiones en orden.

La línea push de la parte-else asigna el nuevo valor del anillo de la muerte a los resultados de agregar la cadena que esta siendo cortada al viejo anillo de la muerte.

Podemos ver cómo funciona esto con un ejemplo.

Primero,

(setq lista-de-ejemplo '("aqui hay una clausula" "otra clausula"))

Después de evaluar esta expresión con C-x C-e, se puede evaluar lista-de-ejemplo y ver que devuelve:

> lista-de-ejemplo
("aquí hay una claúsula" "otra claúsula")

Ahora, podemos agregar un nuevo elemento a esta lista evaluando la siguiente expresión:

(push "una tercera cláusula" lista-de-ejemplo)

Cuando evaluamos lista-de-ejemplo, encontramos que su valor es:

> lista-de-ejemplo
("una tercera claúsula" "aquí hay una claúsula" "otra claúsula")

Asi pues, la tercer claúsula se añade a la lista con push.

Ahora la segunda parte de la claúsula if. Esta expresión evita que el anillo de la muerte crezca demasiado:

(if (> (length kill-ring) kill-ring-max)
    (setcdr (nthcdr (1- kill-ring-max) kill-ring) nil))

El código comprueba si la longitud del anillo de la muerte es mayor al tamaño máximo permitido. Este es el valor de kill-ring-max (que es 60, por defecto). Si el tamaño del anillo de la muerte es demasiado largo, entonces este código establece el último elemento del anillo de la muerte a nil. Hace esto usando dos funciones, nthcdr y setcdr.

Vimos setcdr anteriormente (ver Seccion setcdr). Esto asigna el cdr de una lista, asi como setcar asigna el car de una lista. En este caso, sin embargo, setcdr no estará configurando el cdr del anillo de la muerte completo; se usa la función nthcdr para asignar el cdr del último elemento del anillo de la muerte––esto significa que puesto que el cdr del penultimo elemento es el ultimo elmento del anillo de la muerte, establecera el último elemento del anillo de la muerte.

La función nthcdr funciona tomando repetidamente el cdr de una lista––toma el cdr del cdr del cdr …. hace esto N veces y devuelve los resultados. (Consulta la Seccion nthcdr.)

De este modo, si teniamos una lista de cuatro elementos que supuestamente debia tener tres elementos de longitud, podriamos asignar el cdr del elemento siguiente al último a nil, y asi acortar la lista. (Si se asigna el último elemento en algún otro valor distinto a nil, que se podría hacer, entonces no se habría acortado la lista. Consulta la Sección setcdr.)

Puedes ver el acortamiento evaluando las siguientes tres expresiones. Primero asigna el valor de arboles a (arce roble pino abedul) luego establece el cdr de su segundo cdr y despues encuentra el valor de arboles.

> (setq arboles '(arce roble pino abedul))
(arce roble pino abedul)
> (setcdr (nthcdr 2 arboles) nil)
nil
> arboles
(arce roble pino)

(El valor devuelto por la expresión setcdr es nil, ya que en esto se establece el cdr.)

Para repetir, en kill-new, la función nthcdr toma el cdr un número de veces, que es uno menos que el tamaño máximo permitido del anillo de la muerte y setcdr establece el cdr de este elemento (que será el resto de los elementos en el anillo de la muerte) en nil. Esto evita que el anillo de la muerte se alargue demaciado.

La penultima expresión en la función kill-new es

(setq kill-ring-yank-pointer kill-ring)

kill-ring-yank-pointer es una variable global que se establece para ser el kill-ring.

Apesar de llamar a kill-ring-yank-pointer un ‘puntero’, es una variable al igual que el anillo de la muerte. Sin embargo, el nombre ha sido elegido para ayudar a los humanos a entender cómo se usa la variable.

Ahora, volviendo a una expresión anterior en el cuerpo de la función:

  (if (fboundp 'menu-bar-update-yank-menu)
       (menu-bar-update-yank-menu string (and replace (car kill-ring))))

Empieza con una expresión if

En este caso, la expresión prueba primero si menu-bar-update-yank-menu existe como una función, y si es así, la llama. La función fboundp devuelve verdadero si el símbolo que se prueba tiene una definición de función que ‘no es nula’. Si el símbolo de la definición de función fuera nulo, recibiríamos un mensaje de error, como lo hicimos cuando se crearon errores intencionadamente (Consulta la Seccion Generar un mensaje de error).

La parte-entonces contiene una expresión cuyo primer elemento es la función and.

La forma especial and evalúa cada uno de sus argumentos hasta que uno de los argumentos devuelve un valor de nil, en cuyo caso la expresión and devuelve nil; sin embargo, si ninguno de los argumentos devuelve una valor nil, se devuelve el resultado de la evaluación del último argumento. (Puesto que tal valor no es nil, en Emacs Lisp se considera verdadero.) En otras palabras, una expresión and devuelve un valor verdadero solo si todos sus argumentos son verdaderos. (Consulta la Seccion Revisar el segundo búfer relacionado.)

La expresión determina si el segundo argumento menu-bar-update-yank-menu es verdadero o no.

menu-bar-update-yank-menu es una de la funciones que permiten utilizar el menu ‘Seleccionar y Pegar’ en el elemento Editar de la barra de menu; usando un ratón, puedes ver las distintas piezas de texto que se han guardado y seleccionar una pieza para pegar.

La última expresión en la función kill-new añade la nueva cadena recien copiada a cualquier facilidad existente para copiar y pegar texto entre diferentes programas que se ejecutan en un sistema de ventanas. En el Sistema de Ventanas X, por ejemplo, la función x-select-text toma la cadena y la almacena en la memoria operada por X. Puede pegar la cadena en otro programa, como Xterm.

La expresión se ve asi:

  (if interprogram-cut-function
      (funcall interprogram-cut-function string (not replace))))

Si interprogram-cut-function existe, entonces Emacs ejecuta funcall, que a su vez llama a su primer argumento como una función y le pasa el resto de argumentos. (Por cierto, hasta donde puedo ver, esta expresión if podría reemplazarse por una expresión and similar a la de la primer parte de la función.)

No vamos a discutir mas sobre sistemas de ventanas y otros programas, sino simplemente indicar que este es un mecanismo que le permite a GNU Emacs trabajar bien y fácilmente con otros programas.

Este código para colocar texto en el anillo de la muerte, ya sea concatenandolo con un elemento existente o como un nuevo, nos brinda la habilidad para traer texto que ha sido cortado del búfer––los comandos de corte (yank). Sin embargo, antes de discutir los comandos de corte, es mejor aprender cómo se implementan las listas en un ordenador. Esto pondra de manifiesto misterios como el uso del término ‘puntero’. Pero antes de eso, nos desviaremos a C.

La función copy-region-as-kill (ver Seccion copy-region-as-kill) utiliza la función filter-buffer-substring, que a su vez utiliza la función delete-and-extract-region. Eso elimina el contenido de una región y no se puede recuperar.

A diferencia del otro código discutido aquí, la función delete-and-extract-region no está escrita en Emacs Lisp; está escrita en C y es una de las primitivas del sistema GNU Emacs. Puesto que es muy simple, hare una breve digresión de Lisp y para describirla aquí.

Al igual que muchas de las otras primitivas Emacs, delete-and-extract-region se escribe como una instancia de una macro C, una macro es una plantilla de codigo. La macro completa tiene el siguiente aspecto:

DEFUN ("delete-and-extract-region", Fdelete_and_extract_region,
       Sdelete_and_extract_region, 2, 2, 0,
       doc: /* Borra el texto entre START y END y lo devuelve.  */)
       (Lisp_Object start, Lisp_Object end)
{
  validate_region (&start, &end);
  if (XINT (start) == XINT (end))
    return empty_unibyte_string;
  return del_range_1 (XINT (start), XINT (end), 1, 1);
}

Sin entrar en los detalles del proceso de escritura de la macro, permitame señalar que esta macro comienza con la palabra DEFUN. Se eligio la palabra DEFUN porque el código tiene el mismo propósito que defun en Lisp. (La macro C DEFUN se define en emacs/src/lisp.h.)

La palabra DEFUN tiene siete partes dentro de los paréntesis:

• La primera parte es el nombre dado a la función en Lisp, delete-and-extract-region.

• La segunda parte es el nombre de la función en C, Fdelete_and_extract_region. Por convención, comienza con ‘F’. Puesto que C no usa guiones en los nombres, en su lugar se utilizan guiones bajos.

• La tercera parte es el nombre para la estructura constante C que registra información sobre esta función para uso interno. Es el nombre de la función en C pero empieza con una ‘S’ en lugar de una ‘F’.

• Las partes cuarta y quinta especifican el número mínimo y máximo de argumentos que la función puede tener. Esta función requiere exactamente 2 argumentos.

• La sexta parte es casi como el argumento que sigue a la declaración interactive en una función escrita en Lisp: una letra seguida, tal vez, por un prompt. La única diferencia con Lisp es cuando se llama a la macro sin argumentos. Entonces se escribe un 0 (que es una ‘cadena nula’), como en esta macro.

  Si fueras a especificar argumentos, se colocarian entre comillas. La macro C para goto-char incluye "NGoto char " en esta posición se indica que la función espera un prefijo sin procesar, en este caso, una localización numérica en un búfer, y proporciona un prompt.

• La séptima parte es una cadena de documentación, igual a la de una función escrita en Emacs Lisp. Se escribe como un comentario C. (Cuando se construye Emacs, el programa lib-src/make-docfile extrae estos comentarios y los usa para crear la documentación “real”.)

En una macro C, los parámetros formales vienen a continuacion, con una declaracion de que tipo de objeto son, seguido por lo que podría llamarse el ‘cuerpo’ de la macro. Para delete-and-extract-region el ‘cuerpo’ se compone de las cuatro líneas siguientes:

validate_region (&start, &end);
if (XINT (start) == XINT (end))
  return build_string ("");
return del_range_1 (XINT (start), XINT (end), 1, 1);

La función validate_region comprueba si los valores pasados como el principio y fin de la región son del tipo apropiado y estan dentro del rango. Si las posiciones de inicio y fin son las mismas, entonces devuelve una cadena vacía.

La función del_range_1 borra el texto. Es una función compleja que no examinaremos. Actualiza el búfer y hace otras cosas. Sin embargo, vale la pena mirar los dos argumentos pasados a del_range. Estos son XINT (start) y XINT (end).

Por lo que respecta al lenguaje C, start y end son dos enteros que marcan el principio y el fin de la región a eliminar¹⁰.

En las primeras versiones de Emacs, estos dos números tenian 32 bits de longitud, pero el código está lentamente siendo generalizado para manejar otras longitudes. Tres de los bits disponibles son usados para especificar el tipo de información; los bits restantes se utilizan como ‘contenido’.

XINT es una macro C que extrae el numero relevante desde una colección mas larga de bits; los otros tres bits se descartan.

El comando en delete-and-extract-region se ve asi:

del_range_1 (XINT (start), XINT (end), 1, 1);

Borra la región entre la posición inicial, start, y la posición final, end.

Desde el punto de vista de la persona que escribe Lisp, Emacs es muy simple; pero oculta en el fondo mucha complejidad para hacer que todo funcione.

La función copy-region-as-kill esta escrita en Emacs Lisp. Dos funciones dentro de ella, kill-append y kill-new, copian una región en un búfer y la guardan en una variable llamada kill-ring. Esta sección describe cómo se crea e inicializa la variable kill-ring usando la forma especial defvar.

(De nuevo, se señala que el término kill-ring es un mal nombre. El texto que se corta del búfer puede ser traido de vuelta; no es un anillo de cadaveres, sino un anillo de texto resucitable.)

En Emacs Lisp, una variable como kill-ring se crea y se le da un valor inicial usando la forma especial defvar. El nombre proviene de “definir variable”.

La forma especial defvar es similar a setq en la que se establece el valor de una variable. Se diferencia de setq en dos formas: primero solo establece el valor de la variable si la variable no tiene ya un valor. Si la variable ya tiene un valor, defvar no sobreescribe el valor existente. Segundo, defvar tiene una cadena de documentación.

(Otra forma especial, defcustom, está diseñada para variables que las personas personalizan. Tiene más funcionalidades que defvar. (Consulta la Sección Especificar variables usando defcustom.)

Se puede ver el valor actual de una variable, cualquier variable, usando la función describe-variable, que normalmente se invoca escribiendo C-h v. Si presionas C-h v y luego escribes kill-ring (seguido por RET), veras lo que hay actualmente en tu anillo de la muerte––¡puede ser bastante grande! Por el contrario, si no has estado haciendo nada en esta sesión en Emacs, excepto leer este documento, es posible no tener nada en el. Ademas, se verá la documentación de kill-ring:

Documentación:
Lista de secuencias de texto muerto.
Ya que el anillo de la muerte se supone que interactua bien con
el copia-y-pega que ofrecen los sistemas de ventanas, el uso de
esta variable debería interactuar bien con las funciones
‘interprogram-cut-function’ e ‘interprogram-paste-function’.
Las funciones ‘kill-new’, ‘kill-append’, y ‘current-kill’ deben
implementar esta interacción; es posible que desee utilizarlas
en lugar de manipular el anillo de la muerte directamente.

El anillo de la muerte es definido por un defvar del siguiente modo:

(defvar kill-ring nil
  "Lista de secuencia de texto muerto.
…")

En esta definición de variable, a la variable se le da un valor inicial de nil, lo que tiene sentido, ya que si no has guardado nada, no quieres nada de vuelta al dar un comando yank. La cadena de documentación se escribe igual que la cadena de documentación de un defun. Al igual que con la cadena de documentacion del defun, la primera linea de la documentación deberia ser una frase completa, ya que algunos comandos, como apropos, imprimen solo la primer línea de documentación. Las líneas sucesivas no deben indentarse; de lo contrario, se veran extrañas cuando se use C-h v (describe-variable).

En el pasado, Emacs usaba la forma especial defvar tanto para variables internas que se esperaba que un usuario cambiara como para las que no se esperaban cambios de parte del usuario. Aunque todavía se puede usar defvar para variables personalizadas, por favor, utiliza defcustom en su lugar, ya que esa forma especial proporciona una ruta a los comando de personalización. (Consulta la Seccion Especificar variables usando defcustom.)

Cuando se especifica una variable utilizando la forma especial defvar, se podría distinguir una variable que un usuario puede querer cambiar de las demas escribiendo, ‘*’, en la primera columna de su cadena de documentación. Por ejemplo:

(defvar shell-command-default-error-buffer nil
  "*Nombre de buffer para ‘shell-command’ … salida de error.
… ")

Podrías (y todavía puedes) usar el comando set-variable para cambiar temporalmente el valor de shell-command-default-error-buffer. Sin embargo, las opciones configuradas usando set-variable solo se establecen durante la duración de tu sesión actual. Los nuevos valores no se guardan entre sesiones. Cada vez que Emacs inicia, lee el valor original, a menos que cambie el valor dentro de su fichero .emacs, ya sea configurándolo manualmente o utilizando customize. Consulta la Seccion Tu Fichero .emacs.

Para mí, el mayor uso del comando set-variable es sugerir variables que se podría querer establecer en mi fichero .emacs. Ahora hay más de 700 variables, demasiadas para recordarlas fácilmente. Afortunadamente, se puede presionar TAB después de llamar al comando M-x set-variable para ver la lista de variables. (Consulta la Seccion Examinando y Configurando Variables en El Manual de GNU Emacs.)

Aquí hay un breve resumen de algunas funciones introducidas recientemente.

car, cdr

car devuelve el primer elemento de una lista; cdr devuelve el segundo y los siguientes elementos de una lista.

Por ejemplo:

> (car '(1 2 3 4 5 6 7))
1
> (cdr '(1 2 3 4 5 6 7))
(2 3 4 5 6 7)

cons

cons construye una lista enlazando su primer argumento a su segundo argumento.

Por ejemplo:

> (cons 1 '(2 3 4))
(1 2 3 4)

funcall

funcall evalúa su primer argumento como una función. Pasa los argumentos restantes a su primer argumento.

nthcdr

Devuelve el resultado de tomar el cdr ‘n’ veces en una lista. El nᵗʰ (enesimo) cdr. El ‘resto del resto’, por asi decirlo.

Por ejemplo:

> (nthcdr 3 '(1 2 3 4 5 6 7))
(4 5 6 7)

setcar, setcdr

setcar cambia el primer elemento de una lista; setcdr cambia el segundo y los siguientes elementos de una lista.

Por ejemplo:

> (setq triple '(1 2 3))
> (setcar triple '37)
> triple
(37 2 3)
> (setcdr triple '("foo" "bar"))
> triple
(37 "foo" "bar")

progn

Evalúa cada argumento en secuencia y luego devuelve el valor del último.

Por ejemplo:

> (progn 1 2 3 4)
4

save-restriction

Graba cualquier reduccion (narrowing) que esté en efecto en el búfer actual, si la hay, y restablece esa reduccion despues de evaluar los argumentos.

search-forward

Busca una cadena y, si se encuentra, mueve el punto. De manera similar, para una expresión regular utiliza re-search-forward. (Consulta la Sección Búsqueda de Expresiones Regulares, para obtener una explicación de los patrones y busquedas de expresiones regulares.)

search-forward y re-search-forward toman cuatro argumentos:

1. La cadena o expresión regular a buscar.

2. Opcionalmente, el límite de la búsqueda.

3. Opcionalmente, que hacer si la búsqueda falla, devuelve nil o un mensaje de error.

4. Opcionalmente, cuántas veces repetir la búsqueda; si es negativa, la búsqueda va hacia atrás.

kill-region, delete-and-extract-region, copy-region-as-kill

kill-region corta el texto entre el punto y la marca del búfer y almacena ese texto en el anillo de la muerte, para que puedas recuperarlo "tirando" de el.

copy-region-as-kill copia el texto entre punto y marca dentro del anillo de la muerte. La función no corta ni elimina el texto del búfer.

delete-and-extract-region elimina el texto entre el punto y la marca del búfer. No puede recuperarse. (Este no es un comando interactivo.)