> For the complete documentation index, see [llms.txt](https://overleaf-pro.ayaka.space/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://overleaf-pro.ayaka.space/latex/es/mas-temas/22-how-tex-macros-actually-work-part-4.md). # Cómo funcionan realmente las macros de TeX: Parte 4 [Parte 1](/latex/es/mas-temas/19-how-tex-macros-actually-work-part-1.md) [Parte 2](/latex/es/mas-temas/20-how-tex-macros-actually-work-part-2.md) [Parte 3](/latex/es/mas-temas/21-how-tex-macros-actually-work-part-3.md) [Parte 4](/latex/es/mas-temas/22-how-tex-macros-actually-work-part-4.md) [Parte 5](/latex/es/mas-temas/23-how-tex-macros-actually-work-part-5.md) [Parte 6](/latex/es/mas-temas/24-how-tex-macros-actually-work-part-6.md) ## Introducción y panorama general En las partes 1–3 hicimos una inmersión profunda en algunos detalles de fondo de bajo nivel como preparación para entender cómo funcionan las macros de TeX. En este artículo vamos a “salir a tomar aire” para repasar algunos principios prácticos básicos de las macros de TeX, de cara a otra inmersión profunda en las partes 5 y 6. A lo largo de este artículo mostraremos ejemplos de macros definidas usando el comando primitivo de TeX `\def`: no usaremos el, quizá más familiar, comando LaTeX `\newcommand`. Hay una muy buena razón para ello: nuestro objetivo es entender los principios fundamentales que subyacen al comportamiento de las macros de TeX, pero para hacerlo necesitamos usar comandos básicos *incorporadas en* del software TeX. Los comandos de LaTeX, como `\newcommand`, son en sí mismos macros: comandos con un comportamiento programado específico que, en última instancia, se construyen a partir de capas de comandos primitivos de TeX de nivel inferior. Para entender mejor el comportamiento fundamental de TeX tenemos que usar primitivas de TeX, no macros de LaTeX. ### ¿Hacia dónde vamos? En esencia, estamos trabajando hacia una explicación de las macros como una forma especializada de lista de tokens: cuando le indicas a TeX que defina una macro, crea una secuencia de tokens (una lista de tokens) y la almacena en su memoria vinculada a un nombre que tú defines. En las partes 5 y 6 veremos las listas de tokens de las macros con cierto detalle, pero si prefieres saltar desde este artículo para leer algo de información de fondo puedes encontrarla en [¿Qué es una lista de tokens de TeX?](/latex/es/articulos-en-profundidad/54-what-is-a-tex-token-list.md) Las listas de tokens para las macros, y sus parámetros, incorporan algunos giros adicionales que trabajaremos en detalle, y usaremos muchos ejemplos. Para comprender mejor el comportamiento de procesamiento de macros de TeX, realmente hay un factor clave que recordar: TeX solo piensa en caracteres en la etapa más temprana del procesamiento de entrada: a partir de ahí, ¡todo son tokens! A lo largo de este y de los artículos restantes de esta serie, exploraremos el papel que desempeñan los tokens en las macros de TeX. ## Las cuatro partes de una macro ### Recordatorio: parámetros de macro y argumentos de macro Antes de empezar, conviene recordar la diferencia entre los *parámetros* y los *argumentos*argumentos ``` \def\foo#1#2{Esto es #1, esto es #2} ``` Los constructos (tokens) `#1`, `#2` (hasta `#9`) se llaman *parámetros*: piénsalo como “marcadores de posición” para los datos reales que usarás cuando invoques la macro: ``` \foo{alpha}{beta} ``` Aquí, `alpha` y `beta` son los *argumentos* usados con esta llamada de \foo: los argumentos de una macro son los valores reales que se introducen en los marcadores de posición de los parámetros (`#1`, `#2`... `#9`) usados cuando definiste la macro. ### Definición de macro: tiene 4 elementos Empezaremos con lo que, quizá, parece una definición de macro ligeramente formal, pero sí proporciona un marco útil para posteriores discusiones. Toda definición de macro consta de 4 partes: ``` {} ``` donde: * ``: una de `\def`, `\edef`, `\gdef` o `\xdef`; * ``: el nombre asignado a tu comando de macro, como `\\foo`; * ``: esto puede estar ausente, pero, si está presente, es una serie de *tokens* que aparecen antes de los `` de la macro. Los `` pueden contener parámetros de macro (`#1`, `#2`... `#9`) y otros tipos de tokens. En esencia, y como veremos en detalle, los `` proporcionan una especie de *plantilla de tokens* que TeX usa para averiguar qué tokens quiere usar el usuario como argumentos de la macro: cuando llamas a una macro, TeX introduce los *argumento* tokens en la `` (que también es una lista de tokens); * `{}`: este es el cuerpo real de tu macro: es una serie de tokens en la que los *argumentos* se “inyectan” cuando la macro se procesa (se expande). Los argumentos se introducen en las posiciones indicadas por los parámetros de macro usados en la definición original. **NOTA**: A lo largo de la discusión asumimos que `` irá seguido de un carácter de espacio de código de categoría 10 para actuar como delimitador y terminar el ``. Nosotros *no hemos* mostrado explícitamente ese carácter de espacio en nuestro texto/discusión, pero asumimos que está ahí. Estrictamente hablando, deberíamos representarlo algo así: ``` {} ``` Sin embargo, omitiremos la inclusión explícita de un `` carácter y asumiremos implícitamente su presencia. #### Notas sobre {} Hemos mostrado el uso de dos llaves: `{` y `}` que encierran (delimitan) el cuerpo real de tu ``. Sin embargo, el uso de `{` y `}` es solo una convención adoptada porque lo que TeX realmente espera es que el texto de tu macro `` empiece con un carácter de código de categoría 1 (“Iniciar un grupo”) y termine con un carácter de código de categoría 2 (“Fin de un grupo”). Por convención, estos son los `{` y `}` caracteres, respectivamente. Sin embargo, si quieres, puedes asignar cualquier par de caracteres para hacer eso. Por ejemplo ``` \catcode`\(=1 \catcode`\)=2 ``` Ahora, puedes definir y usar macros como esta: ``` \def\foo #1(Hola, #1) \foo(Mundo!) ``` Y todavía puedes usar `{` y `}` porque no hemos cambiado sus códigos de categoría: múltiples caracteres pueden, y de hecho lo hacen, tener el mismo código de categoría, así que puedes seguir definiendo macros de la manera habitual: ``` \def\foo #1{Hola, #1} \foo{Mundo!} ``` ### y {} Los componentes de la definición de una macro más relevantes para nuestra discusión son `` y `{}`. Cuando defines una macro, el `` es, en efecto, una plantilla estricta de tokens que define cómo debe usarse la macro. Como se ha señalado, `` puede estar vacío, por ejemplo, `\def\foo{Algún texto}` donde no aparece nada entre el nombre del comando (`\\foo`) y la llave de apertura `{` que, aquí, señala el inicio del ``. **Nota**de la macro: algunos lectores quizá conozcan el mecanismo de “hashquote” de TeX (`#{`) pero no lo trataremos aquí. ### y delimitadores de macro Este artículo en particular no está diseñado como una revisión exhaustiva de la escritura de macros, pero vale la pena hacer un breve repaso, con algunos ejemplos, que muestre que el `` puede volverse complejo porque TeX permite `` contener: * **parámetros de macro**: (`#1`, `#2`,... `#9`) que actúan como “marcadores de posición” para valores que el usuario proporcionará cuando ejecute la macro —los *argumentos*; * **tokens delimitadores**: tokens arbitrarios, intercalados en/alrededor de los tokens de parámetro, y usados para especificar el límite entre parámetros de macro. Puedes pensar en esos delimitadores como si formaran una especie de “puntuación” que hace que los `` una “plantilla de tokens” que tendrás que seguir cuando uses la macro. Los tokens delimitadores no se imprimen. Entonces, ¿qué significa esto realmente? Veamos algunos ejemplos. El `` se sitúa entre el nombre de la macro y la llave izquierda `{` de la definición de la macro. #### Delimitadores: ejemplo 1 Supongamos que definimos una macro básica `\\foo` de la siguiente manera: ``` \def\foo ABC{hola, allí} ``` * `` = `ABC` * No hay tokens de parámetro (`#1`, `#2`,... `#9`) * Los delimitadores son los *tres tokens de carácter* `ABC` pero, en este ejemplo, son algo superfluos y se usan solo como ejemplo. Los tres tokens de carácter `ABC` se tratan como delimitadores: no como algo que deba imprimirse, sino como “puntuación” que se espera que esté presente cuando se llama a la macro —cuando usas la macro `\\foo` tienes que proporcionar los mismos delimitadores que estaban presentes cuando se definió. Si escribes `\foo ABC` dentro de tu texto esto se imprimirá como `hola, allí`—los tokens de carácter `ABC` no se imprimen, pero TeX sí comprobó, muy cuidadosamente, que estuvieran presentes en tu invocación (llamada) de `\\foo`. TeX busca esos delimitadores (“puntuación”) y los elimina (absorbe), como puedes ver en la siguiente imagen de pantalla de Overleaf: `ABC` no se imprime: ![Overleaf ejecutando una macro de TeX](/files/b8d06e91401214d5583ad4ad9b218580abcd8ff8) Si intenta usar `\\foo` sin los `ABC` delimitadores, TeX se quejará `El uso de \foo no coincide con su definición.`: ![Mostrando un error de TeX en Overleaf](/files/939d806dbce96a7ed823d63dbb7caac0d571a36c) En el ejemplo anterior, después de detectar `\\foo` TeX espera ver los tres tokens de carácter `ABC` pero no lo hace: ve el token de carácter para `w` y detecta inmediatamente que algo va mal. #### Delimitadores: ejemplo 2 Un hecho interesante, y quizá sorprendente, es que los delimitadores pueden ser tokens de comando arbitrarios, incluidos comandos que *ni siquiera se han definido*. Por ejemplo, podríamos definir `\\foo` como: ``` \def\foo A\bob B\anne{Hola \TeX{}} ``` * `` = `A\bob B\anne` * No hay tokens de parámetro (`#1`, `#2`,... `#9`) * Los delimitadores son los tokens `A\bob B\anne` pero de nuevo, en este ejemplo, son superfluos y solo sirven para fines de discusión. Ten en cuenta que `\bob` y `\anne` son comandos ficticios que *no se definieron*—y no necesitan estarlo. Cuando llamas a una macro, TeX comprueba (analiza) los `` que está presente *en tu llamada a la macro* y lo compara, token por token, con la versión de “plantilla de tokens” *almacenada en memoria*—la creada en el momento en que se definió la macro. TeX analiza los *usados en tu llamada a la macro* y simplemente convierte cualquier comando que encuentre allí en su valor numérico de token: no está intentando ejecutar esos comandos, por lo tanto no importa que `\bob` y `\anne` nunca se definieran `` TeX simplemente usa la plantilla de tokens almacenada en memoria como una guía que le permite averiguar qué tokens en la ``. de tu llamada a la macro son los argumentos reales que hay que introducir en los`A` y `B`) dentro de `A\bob B\anne` Como puedes ver en el siguiente fragmento de pantalla de Overleaf, ninguno de los tokens de carácter ( `\bob` y `\anne` se imprimió y nuestros comandos no definidos *no causaron ningún problema. Todos estos tokens fueron* absorbidos `\\foo` por TeX, al hacer coincidir tu uso de `\\foo` con la definición (plantilla de tokens) de ![Overleaf ejecutando una macro de TeX](/files/8fff0549623f317f1f790eae751df1dba5dd38e6) #### Delimitadores: ejemplo 3 Puedes intercalar varios delimitadores (tokens de carácter, tokens de comando) con parámetros de macro, como en este ejemplo: ``` \def\foo A\bob#1B\anne#2\jane#3bye!{Hola desde \TeX{} a \#1=#1, \#2=#2 y \#3=#3} ``` * `` = `A\bob#1B\anne#2\jane#3bye!` * Hay 3 tokens de parámetro: `#1`, `#2`, `#3` * Esta vez, los parámetros (`#1`, `#2`, `#3`) están delimitados por una combinación de tokens: `A\bob#1B\anne#2\jane#3bye!` Aquí, en efecto, has proporcionado a TeX una plantilla que intentará muy cuidadosamente, y esperará, hacer coincidir cuando llames a `\\foo`: recorrerá tu llamada a la macro, *token por token*, y esperará hacer coincidir (encontrar): * los dos tokens `A` y `\bob` antes de que `#1` * los dos tokens `B` y `\anne` antes de que `#2` * el token `\jane` antes del parámetro `#3` y el *cuatro tokens de carácter* `b`, `y`,`e` y `!` después de `#3`. **Recuerda**: TeX piensa en tokens, así que `¡adiós!` es *cuatro tokens de carácter*. Hay dos formas en que podemos usar esta macro: podríamos poner cualquier argumento de varios tokens entre llaves para proporcionar un grupo: ``` \foo A\bob{Esto}B\anne{Eso}\jane{Otro}bye! ``` Sin embargo, eso *no es necesario* porque nuestra definición de macro tiene delimitadores que proporcionan una plantilla de tokens. TeX puede usar esa plantilla para seleccionar los tokens de cada argumento entre tokens que son puramente delimitadores. Podemos usar nuestra macro así: ``` \foo A\bob EstoB\anne Eso\jane Otrobye! ``` y TeX puede seleccionar los argumentos para producir el mismo resultado que al usar grupos `{...}`: ![Overleaf ejecutando una macro de TeX usando delimitadores](/files/b552bcb7a56293007aa04869e19972c8fbf98590) Fíjate en cómo TeX fue capaz de detectar, con precisión, qué tokens coincidían con parámetros `#1` y `#3`: ![Overleaf ejecutando una macro de TeX usando delimitadores](/files/56978960d897f2e8137d9b2745269ad84cfbb41b) #### Delimitadores: ejemplo 4 (¡todo tiene que ver con tokens, no con caracteres!) Aquí hay un breve ejemplo para demostrar que, al trabajar con macros, es importante recordar que realmente estamos en el mundo de los *tokens* y **no** *caracteres*… Definiremos la siguiente macro breve donde A y B son caracteres que actúan como delimitadores y ambos tienen código de categoría 11. Esto funciona sin problemas: ``` \documentclass{article} \begin{document} \def\foo A#1B{Hola, #1} \foo AGrahamB \end{document} ``` y se imprime como `Hola, Graham`. Sin embargo, si cambias el código de categoría de A o B a algo distinto de 11, la llamada a la macro fallará. Supongamos que cambiamos el código de categoría de B a 12, usando ``\catcode`B=12`` y tratamos de llamar de nuevo a la macro, como antes: ``` \documentclass{article} \begin{document} \def\foo A#1B{Hola, #1} \foo AGrahamB % Esto funciona \catcode`\B=12\relax \foo AGrahamB \end{document} ``` Falla con un error algo desconcertante: ``` ¿Argumento desbocado? GrahamB \end {document} ! El archivo terminó mientras se analizaba el uso de \foo. \par <*> main.tex Creo que has olvidado una `}', lo que me lleva a leer más allá de donde querías que me detuviera. Intentaré recuperarme; pero si el error es grave, será mejor que escribas ahora `E' o `X' y corrijas tu archivo. ! Parada de emergencia. <*> main.tex *** (trabajo abortado, no se encontró ningún \end válido) ``` ![Overleaf mostrando un error de macro de TeX](/files/c7912bd35c2318828ac9ed6d35508a4809f077e6) Desafortunadamente, la sugerencia predeterminada de TeX de ``Creo que has olvidado una `}'`` es **incorrecta**, no está causada por una llave faltante (`}`). #### ¿Qué ha sucedido? TeX está intentando hacer coincidir la `\\foo` macro *llamada* con la `\\foo` macro *definition* que tiene almacenada en memoria. Cuando llamas a una macro que necesita uno o más argumentos, TeX tiene que examinar (analizar) tu uso de la macro para averiguar los *argumentos* que estás proporcionando a esa macro. Aquí, TeX espera que el argumento esté encajado entre una A (código de categoría 11) y una B (código de categoría 11). Recuerda: TeX está pensando en *tokens*, **no** *caracteres*. Los valores de token para A y B, $$\mathrm{T\_A}$$ y $$\mathrm{T\_B}$$ respectivamente, son: $$\mathrm{T\_A = 256 \times 11 + 65 = 2881}$$ $$\mathrm{T\_B = 256 \times 11 + 66 =2882}$$ Sin embargo, a medida que TeX continúa su búsqueda ve la B *pero* ahora tiene código de categoría 12 y eso da como resultado un valor de token diferente: $$\mathrm{T'\_B= 256 \times 12 + 66 =3138}$$ En la `\\foo` definición de macro, el valor de token para B (usado como delimitador) era 2882, pero TeX ahora ve un valor de token de 3138: piensa que esto es solo otro token destinado a ser usado en la *argumento* suministrados a `\\foo`. En lo que a TeX respecta, el token final del argumento aún no se ha encontrado, así que pasa a obtener otro token en su búsqueda de una B con código de categoría 11. Ahí es cuando, y por qué, falla la macro: en su intento de encontrar el argumento, TeX “se pasa de largo” y empieza a leer tokens que no pretendías que formasen parte del argumento para la `\\foo` llamada a la macro. Lo que ocurre después depende de los tokens que TeX descubra tras la B: desencadenarán diversos `¿Argumento desbocado?` errores. En nuestro ejemplo, TeX se pasa de largo y consume la secuencia de tokens `\end {document}` y alcanza rápidamente el final del archivo, de ahí el mensaje de error: ``` ! El archivo terminó mientras se analizaba el uso de \foo ``` ## Parte 5 Como vimos arriba, la `` sección de la definición de nuestra macro puede abarcar desde algo extremadamente simple hasta una mezcla compleja de parámetros de macro intercalados con tokens de carácter y tokens de comando que actúan como delimitadores. TeX es capaz de procesar la combinación de tokens presente en `` para extraer los argumentos proporcionados a una macro —y detectar cuándo intentamos usar una macro incorrectamente. Cómo lo hace es el tema del siguiente artículo de la serie. [Parte 1](/latex/es/mas-temas/19-how-tex-macros-actually-work-part-1.md) [Parte 2](/latex/es/mas-temas/20-how-tex-macros-actually-work-part-2.md) [Parte 3](/latex/es/mas-temas/21-how-tex-macros-actually-work-part-3.md) [Parte 4](/latex/es/mas-temas/22-how-tex-macros-actually-work-part-4.md) [Parte 5](/latex/es/mas-temas/23-how-tex-macros-actually-work-part-5.md) [Parte 6](/latex/es/mas-temas/24-how-tex-macros-actually-work-part-6.md) --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter: ``` GET https://overleaf-pro.ayaka.space/latex/es/mas-temas/22-how-tex-macros-actually-work-part-4.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.