> 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/da/dybtgaende-artikler/22-how-does-expandafter-work-the-meaning-of-expansion.md).
# Hvordan virker \expandafter: Betydningen af udvidelse
[Del 1](/latex/da/dybtgaende-artikler/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Del 2](/latex/da/dybtgaende-artikler/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Del 3](/latex/da/dybtgaende-artikler/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Del 4](/latex/da/dybtgaende-artikler/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Del 5](/latex/da/dybtgaende-artikler/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Del 6](/latex/da/dybtgaende-artikler/18-how-does-expandafter-work-a-detailed-study-of-consecutive-expandafter-commands.md)
## Introduktion til TeXs begreb om “ekspansion”
Efter at have gennemgået [TeX-tokens og tokenlister](https://www.overleaf.com/learn/latex/Articles/\expandafter_TeX_tokens?preview=true), er næste emne på vores liste over baggrundsemner for `\expandafter` er TeXs begreb om *udvidelse*: den centrale TeX-proces `\expandafter` er designet til at arbejde med.
### Om udfordringen ved at forklare ekspansion...
For de fleste af os kan TeXs begreb om ekspansion og årsagerne/mekanismen(e) bag det være forvirrende—de er ikke lette at *fuldt ud* forklare på en enkel og kortfattet måde. Mange af TeXs indre operationer/processer hænger sammen på ret komplekse måder, hvilket kan give udfordringer, når man forsøger at “adskille” bestemte aspekter af TeXs operationer: forsøger at diskutere dem isoleret fra programmet som helhed. Ekspansion er bestemt et begreb, der falder ind under denne kategori, fordi det er et *grundlæggende* element i TeXs adfærd og dybt indlejret i hele TeXs indre processer. Denne artikel forsøger dog at konstruere en forklaring på ekspansion og tilbyde et grundlag, som læserne kan bygge videre på.
For at forklare TeXs ekspansionsmekanisme vil vi gå frem trin for trin, gennemgå en række beslægtede/relevante emner og sætte dem sammen for at udvikle en forståelse af dette afgørende element i TeXs adfærd. Senere i artiklen, og for den mere eventyrlystne læser, der holder af detaljer, ser vi nærmere ind i selve TeX og opsummerer den centrale kildekode, der styrer ekspansionsprocessen.
### Vigtige punkter om TeX-tokens
Under den følgende diskussion er det vigtigt at huske, at TeX kan hente sin næste inputenhed fra to kilder:
1. **fysiske tekstfiler**: ved at generere *nye tokens* ved at læse/scanne tegn og kommandoer i disse filer, eller
2. **tokenlister**: ved at få input ved at læse fra en liste over eksisterende, *forberedte*, tokens gemt i TeXs hukommelse.
Husk også, at TeX bruger tokens som en praktisk måde til pænt at “pakke” information om enhver enhed (tegn eller kommando), den har læst ind.
Når TeX genererer *nye tokens* vil den, *på selve tidspunktet for tokenproduktionen*, have øjeblikkelig adgang til information om den enhed, hvis tokenværdi den beregner. For eksempel, når der genereres nye kommandotokens, beregner TeX først en værdi kaldet `curcs` der gør det muligt for TeX at slå information op om den kommando, hvis token den er ved at producere.
Men hvis TeX læser fra tokenlister (sekvenser af *gemte tokens*) ville den først være nødt til at “pakke” enhver token i den liste ud, før den kunne afgøre, hvad hver token repræsenterer. For eksempel kunne TeX læse tokens, der er gemt som en del af en makrodefinition: de tokens ville være blevet genereret ud fra tekst, som for længst er blevet læst ind, omdannet til tokens og lagt til side. Tokentypen (tegn eller kommando) afgør, hvad TeXs “udpakkning” faktisk betyder:
* for *kommandotokens* (tokenværdien er > 4095): beregn `curcs` via $$\text{curcs}=\text{token value}-4095$$ og brug `curcs` til at slå information op om kommandoen;
* for *tegntokens* (tokenværdi < 4095): opdel tegntokenet i dets bestående par af (tegnkode, kategorikode).
### I begyndelsen...
For at begynde vores udforskning af ekspansion vil vi se på, hvordan TeX-maskiner klassificerer eller kategoriserer det sæt af kommandoer, de kan behandle. For øjeblikket kan vi antage, at “ekspanderbar” blot er en endnu uforklaret “egenskab” ved en TeX-kommando.
### Begrebet “ekspanderbare” kommandoer
Alle TeX-baserede satsprogrammer (TeX-“maskiner”) forstår to hoved“klasser” af kommandoer:
* kommandoer indbygget i selve den eksekverbare maskine: de såkaldte *primitiver*;
* kommandoer defineret af brugeren: såkaldte *makroer*.
TeX-maskiner bruger også “at være ekspanderbar”, en type kommando“adfærd”, som en mekanisme til at klassificere alle kommandoer i to grupper:
* ekspanderbare kommandoer;
* ikke-ekspanderbare kommandoer.
Så vi kan betragte det sådan, at mængden af alle kommandoer (primitive kommandoer plus makroer) kan klassificeres som vist i den følgende figur:
Selvom vi endnu ikke ved, hvad ekspansion/ekspanderbar egentlig betyder, er det muligt at se, at:
* alle makroer klassificeres som ekspanderbare kommandoer;
* nogle primitive (indbyggede) kommandoer klassificeres også som ekspanderbare (det store flertal gør ikke).
**Bemærkning om aktive tegn**: Ud over primtive og makroer findes der en tredje klasse af “ekspanderbare” enheder: aktive tegn—alle tegn, der er tildelt kategorikode 13, betragtes også som “ekspanderbare”, fordi de behandles som “miniaturemakroer”.
#### Hvordan ved TeX, om en kommando er “ekspanderbar”?
Fra vores [diskussion af TeX-tokens](https://www.overleaf.com/learn/latex/Articles/\expandafter_TeX_tokens?preview=true) ved vi, at tokens ikke er andet end heltal, som TeX beregner og bruger til at “pakke” information om en inputenhed: et tegn eller en kommando. Vi bemærkede også, at givet enhver tokenværdi (heltal) kan TeX, hvis/når det er nødvendigt, vende tokeniseringsprocessen om for at “pakke” en token ud og afsløre data om den kommando eller det tegn, den repræsenterer.
Ved at bruge data, der produceres, når TeX opretter en ny token, eller data udtrukket fra en eksisterende token—f.eks. en, der er gemt i en makro eller anden tokenliste—kan TeX kontrollere sine interne datalagringstabeller for at finde detaljerede oplysninger om den kommando (eller det tegn), som den token repræsenterer. Den følgende figur opsummerer processen med at oprette en kommandotoken (“pakning”) og derefter, når TeX har brug for oplysninger, vende processen (“udpakkning” af tokenen) for at få data om den kommando, som repræsenteres af en bestemt tokenværdi.
### Kommandakoder
En del af de oplysninger, TeX gemmer om hver kommando (primitive eller makro), er noget, der kaldes dens *kommandokode*: en heltalsværdi, som TeX-maskiner bruger (internt) til at klassificere kommandoer—kommandoer med lignende adfærd/funktionalitet deler den samme kommandokode.
**Bemærk**: For en individuel, *ikke-aktive*, tegn, er dens kommandokode *kategorikode* den værdi, der blev tildelt, da den blev læst ind (scannet) af TeX. Bemærk også, at bortset fra tegn er kommandokoder udelukkende interne i TeX: de er ikke tilgængelige via makroer eller primitive kommandoer—for at se de detaljer må du læse TeXs kildekode!
Her er nogle eksempler på kommandokoder:
* `\hbox`, `\vbox`, `\vtop`, `\vcenter`, `\box` (og andre) klassificeres alle som “boksfremstillende” kommandoer og deler kommandokode 20;
* `\def`, `\edef`, `\gdef`, `\xdef` er alle “makrodefinitions”-kommandoer og deler kommandokode 97;
* alle makroer klassificeres med en af kommandokoderne 111, 112, 113 eller 114: de forskellige kommandokoder bestemmes af brugen af `\long` eller `\outer` ved definitionen af makroen:
* 111: kommandokode for en ikke-long, ikke-outer makro (f.eks., `\def\foo{...}`)
* 112: kommandokode for en long, ikke-outer makro (f.eks., `\long\def\foo{...}`)
* 113: kommandokode for en ikke-long, outer makro (f.eks., `\outer\def\foo{...}`)
* 114: kommandokode for en long, outer makro (f.eks., `\long\outer\def\foo{...}`)
TeX bruger også kommandokoder til at identificere den undergruppe af kommandoer, der klassificeres som “ekspanderbare”. For at gøre det knytter TeX ekspanderbare kommandoer til kommandokodeværdier, der overstiger tærskelværdien 100 (den værdi, der bruges af Knuths oprindelige TeX, e-TeX og pdfTeX). Følgelig:
* *ikke-udvidelige* kommandoer (det store flertal) har en kommandokode <= 100
* *ekspanderbare* kommandoer har en kommandokode > 100
Derfor, hvis TeX slår detaljerne op for en bestemt kommando og registrerer en kommandokode > 100, ved TeX straks, at den er ekspanderbar. Alle makroer og et lille antal primitive (indbyggede kommandoer) tildeles en kommandokode, der angiver, at de er ekspanderbare: men hvorfor gider TeX overhovedet med denne “ekspanderbare” klassificering? Som du måske mistænker, betyder det blot, at disse kommandoer er noget “særlige”; dvs. de kan underkastes TeXs proces med *udvidelse*.
**Bemærkning (tegn)**: Medmindre et tegn er blevet defineret som aktivt (kategorikode 13), er alle tegn ikke-ekspanderbare. Aktive tegn kan betragtes som enkeltbogstavs “minimakroer”.
## Ja, ja, men hvad er ekspansion???
Vi bemærkede, at tokenværdier større end 4095 bruges til at repræsentere kommandoer; følgelig kan TeX, hvis/når det er nødvendigt, “pakke” den token ud for at få adgang til information om den TeX-kommando, som tokenen repræsenterer. TeX kan slå den kommandos kommandokodeværdi op for at afgøre, om den falder ind under den særlige kategori at være ekspanderbar. Men hvad gør TeX med den information, og hvad betyder “at være ekspanderbar”, dvs. ekspansion, *egentlig*?
### Ekspansion: Et generelt udtryk for et sæt operationer
På visse punkter under TeXs behandling har den brug for at vide, om en token repræsenterer en ekspanderbar kommando:
* **Nej**: Hvis den kommandotoken *ikke* falder ind under den ekspanderbare kategori, sender TeX den simpelthen “videre” til næste behandlingsstadie.
* **Ja**: Hvis den kommandotoken *gør* falder ind under den ekspanderbare kategori, kan man tænke på, at TeX må foretage en handling, der resulterer i at “filtrere” netop den token fra ved at udføre en proces, som TeX kalder at “ekspandere den token”, eller at udføre ekspansion.
I bund og grund indebærer ekspansion, at TeX *at fjerne* den token fra sit input og *erstatte* den med tokens, der opstår fra den “ekspansionsproces”, der er specifik for den kommando eller gruppe af kommandoer, som deler den samme kommandokode.
Det kræver øvelse og erfaring at vide, hvornår TeX udfører, og ikke udfører, tokenekspansion—side 215 i The TeXbook oplister de situationer, hvor ekspanderbare tokens ikke ekspanderes. Virkeligheden er, at TeXs proces med at udføre ekspansion er kompleks og nuanceret.
#### Hvilke kommandoer er ekspanderbare?
Hvis man ser på en liste over primitive (indbyggede) kommandoer, som TeX-maskiner klassificerer som ekspanderbare (f.eks. side 212–215 i The TeX book), bliver det tydeligt, at ekspansion i praksis er et ret generelt begreb, som TeX bruger til at beskrive adfærden hos en noget eklektisk gruppe af kommandoer. Resultaterne af ekspansion af en bestemt (ekspanderbar) kommando varierer, og det kan vi se ved at opliste et sæt ekspanderbare kommandoer—grupperet efter deres funktionalitet. Den præcise semantik for individuelle kommandoer er ikke vigtig her; det mest interessante er de generelle konsekvenser af deres handlinger—hvad deres ekspansion faktisk *gør eller opnår*.
| **kommandoen** | **Beskrivelse** | **Ekspansionsadfærd** |
| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| | En gemt sekvens af kommando-/tegntokens | I praksis betyder makroekspansion at indsætte en liste af tokens, som TeX skal læse. Det indebærer:
- at oprette tokenlister for eventuelle makroargumenter—den proces omfatter identifikation/absorbering af skilletegnstokens;
- at hente en liste af gemte tokens (makrodefinitionen) og forberede indsættelse af parametertokens, der blev oprettet i det første trin, i makrodefinitionen.
I praksis betyder makroekspansion fjerner makrotokenen fra inputtet og erstatter den med de tokens, der er indeholdt i definitionen.
|
| | Ændr ekspansionsrækkefølgen | Tokenfiltrering/-omrokering |
| | Forhindre ekspansion (ja, overraskende nok er den klassificeret som en ekspanderbar kommando) | Udsæt ekspansion (en slags tokenfiltrering) |
| \input, \endinput, \scantokens
| Relateret til at indlæse en ny kilde til tokens via kildefiler—ja, `\scantokens` i denne kategori på grund af dens brug af såkaldte “pseudofiler” | Fungerer som en kilde til nye tokens |
| \if, \ifcat, \ifnum, \ifdim, \ifodd, \ifvmode, \ifhmode, \ifmmode, \ifinner, \ifvoid, \ifhbox, \ifvbox, \ifx, \ifeof, \iftrue, \iffalse, \ifcase, \ifdefined, \ifcsname, \iffontchar
| Begynd et betinget udtryk | Start token-“filtrering”: afgør, hvilke af de følgende tokens der skal behandles. |
| | Afslut et betinget udtryk | Stop token-“filtrering”: afgør, hvilke tokens der skal behandles |
| | Konstruer/generer en kommandotoken | Konvertér en række tokens til en enkelt kommandotoken |
| \number, \romannumeral, \string, \meaning, \fontname, \jobname, \eTeXrevision
| Konvertér noget til en sekvens af tokens | Generer nogle tokens (der repræsenterer en intern størrelse eller værdi) |
| \the, \unexpanded, \detokenize
| `\the` har forskellige anvendelser, herunder indsættelse af tokens; `\detokenize` konverterer en tokenliste til en liste af tegntokens; `\unexpanded` forhindrer ekspansion af tokens | Indsæt/generer nogle tokens eller styr ekspansion |
| \topmark, \firstmark, \botmark, \splitfirstmark, \splitbotmark, \topmarks, \firstmarks, \botmarks, \splitfirstmarks, \splitbotmarks
| Kommandoer til adgang til tokenlister, der har specialiserede anvendelser | Få adgang til en kilde af gemte tokens (tokenlister) |
På baggrund af listen ovenfor, er det så muligt at udlede nogle “generelle adfærdsmønstre” fra denne samling af kommandoer—for at forfine vores forståelse af ekspansion yderligere? I en rimelig tilnærmelse falder resultaterne af at ekspandere en kommando i nogle få nøgleaktiviteter:
* tokengenerering
* tokenindsættelse
* tokenfiltrering
* ændre/styre ekspansionen af den næste token
### Og til sidst: betydningen af ekspansion?
Vi kan betragte det sådan, at ekspansion af en kommandotoken (inklusive aktive tegn) indebærer, at TeX **at fjerne** den kommandotoken fra inputtet og **erstatte** den token med andre tokens, der opstår fra dens ekspansionsadfærd: generere/indsætte tokens, filtrere tokens eller ændre/styre ekspansionen af den næste token. Når en token først er blevet ekspanderet, vil TeX fortsætte med at læse/behandle eventuelle tokens, der måtte opstå fra ekspansionsprocessen. Præcis hvornår eller hvor TeX udfører ekspansion, er et helt andet spørgsmål: på grund af nuancerne og kompleksiteten i TeXs behandling er det et spørgsmål, vi ikke kan håbe på at behandle fuldstændigt i denne artikel, men vi kan give et overblik over TeXs primære inputbehandlingsadfærd.
## Ekspansion og TeXs struktur
Måske er den bedste måde at se, hvordan/hvor TeX skelner mellem ekspanderbare og ikke-ekspanderbare kommandoer, at se på TeXs kildekode.
Internt er TeX et ekstremt komplekst stykke software; derfor er det upraktisk at forsøge en fuldstændig beskrivelse af de mange nuancerede adfærdsmønstre, der er indlejret i TeXs funktion. Som nævnt er det præcis hvornår eller hvor TeX faktisk udfører ekspansion, mens det læser tokens, “noget komplekst”; derfor antager følgende diskussion, at TeX befinder sig i en tilstand, der kræver, at ekspansion finder sted. Situationer, hvor TeX ville læse/oprette tokens, men ikke udføre ekspansion, omfatter oprettelse/gemning af tokens til `\def` makrodefinitionskommandoen eller gemning af tokens i en `\toks` register.
Følgende diagram giver et forenklet overblik over de centrale dele af TeXs struktur, som håndterer input og behandling af tokens: målet er at fremhæve den måde, hvorpå ekspanderbare og ikke-ekspanderbare tokens “filtreres” under TeXs inputbehandling. Programmeringssproget C bruges til at beskrive de forskellige nøglefunktioner, men forhåbentlig bør den grundlæggende struktur være klar, selv hvis du ikke er bekendt med C-sproget.
### Forklaring af TeXs strukturdiagram
Overordnet drives TeXs behandling af en funktion kaldet `maincontrol()` som Knuth i TeXs kildekode omtaler som den “øverste direktør” og beskriver således:
> “Nu kommer vi til `maincontrol` rutinen, som indeholder hovedkontakten, der får alle de forskellige dele af TeX til at gøre deres ting i den rigtige rækkefølge… dette er programmets store klimaks… Vi er nu ved nettet nav, det centrale nervesystem, der berører de fleste af de andre dele og binder dem sammen.”
Følgende beskrivelse er noget forenklet, men giver en “fornemmelse” af den underliggende struktur i TeX-baseret software: hvordan ekspanderbare kommandoer identificeres (“opfanges”) og filtreres fra under TeXs inputbehandling.
I det væsentlige bruger TeX i det tidligste stadium af inputbehandlingen værdien af kommandokoden for den aktuelle kommando(token) til at opdage ekspanderbare kommandoer (makroer, ekspanderbare primitive kommandoer og aktive tegn); hvis en sådan identificeres, bliver disse kommandoer “opfanget” og “forbehandlet”—ved at blive ekspanderet. Gennem denne filtrerings-(ekspansions-)proces fjerner TeX ekspanderbare kommandoer fra inputtet og erstatter dem med tokens, der opstår fra deres respektive ekspansionsadfærd. Når ekspansionsprocessen er afsluttet, vil TeX læse alle tokens, der produceres fra den ekspansion. Kun ikke-ekspanderbare enheder sendes videre til næste stadie af TeXs behandling: den “store switch”, hvor TeX vil udføre alle ikke-ekspanderbare primitive kommandoer og sætte tegn.
### Forståelse af maincontrol()
Den `maincontrol()` funktion indeholder en stor såkaldt [switch-sætning](https://en.wikipedia.org/wiki/Switch_statement)—Knuth kalder den den “store switch”—som TeX bruger til at udføre alle *ikke-udvidelige* primitive kommandoer: dem med en kommandokode <=100.
For at udføre en bestemt kommando (eller et tegn) bruger denne “store switch”-sætning en kombination af TeXs aktuelle tilstand:
* indre/ydre vertikal tilstand, eller
* begrænset/afsnitshorisontal tilstand, eller
* inline-/displaymatematisk tilstand
*plus* værdien af kommandokoden for hver primitiv eller tegn—the kommandokode for et *ikke-aktive* tegn er dets *kategorikode* værdi. Til orientering tildeles alle 6 af TeXs tilstande en heltalsværdi, som TeX kan bruge til at gemme og gendanne sin aktuelle tilstand, mens det skifter mellem at sætte forskellige strukturer—matematik, afsnit, bokse og så videre. Her er de heltal, der er tildelt TeXs forskellige tilstande:
| | | |
| -------------------------- | -------------------------------------- | ------------------ |
| **Tilstand** | **Betydning** | **Tilstandsværdi** |
| Ydre vertikal | Mellem afsnit (opbygning af sider) | 1 |
| Indre vertikal | Umiddelbart inde i en `\vbox{...}` | -1 |
| Horisontal | Ved sats/opbygning af afsnit | 102 |
| Begrænset horisontal | Umiddelbart inde i en `\hbox{...}` | -102 |
| Displaymatematik | Sætning af *visning* ligninger/formler | 203 |
| Indlinje-(formel)matematik | Sætning af *linje* ligninger/formler | -203 |
Bemærk brugen af negative værdier for komplementet af de forskellige tilstande, såsom indre vs. ydre vertikal tilstand. Når kommandoer behandles i `maincontrol()`, bruger TeX den absolutte værdi af den aktuelle tilstand—dvs. ignorerer minustegnet. Så for eksempel, hvis TeX befinder sig i en af sine horisontale tilstande og skal behandle et tegn med kategorikode 11, ville det bruge summen $$102 + 11 = 113$$ inde i sin “store switch” til at forgrene til den kode, der behandler disse tegn i en af de horisontale tilstande (opbygning af afsnit eller inde i en `\hbox`).
#### Henter den næste token
Den `maincontrol()` funktion kalder funktionen `getxtoken()` for at hente den næste inputtoken; til gengæld `getxtoken()` kalder den den laveste inputfunktion `getnext()`. Efter `getnext()` har afsluttet sit arbejde og sat værdien af centrale *globale variabler*, `getxtoken()` tester den, om den netop indlæste enhed repræsenterer en makro eller en ekspanderbar primitiv.
Nogle noter om `getnext()` og `getxtoken()`:
* **`getnext()`**: dette er TeXs centrale inputfunktion. Den læser og behandler tegninput fra en fysisk fil eller læser tokens fra en tokenliste. Bemærk, at `getnext()` beregner faktisk ikke tokenværdier, men den sætter en række centrale *globale* variabler (f.eks. kommandokoden og `curcs`) som bruges senere i behandlingen.
* **`getxtoken()`**: “get expanded token” bruger `getnext()` til at læse den næste inputenhed. Derefter tester den kommandokoden for den netop indlæste enhed for at kontrollere, om den enhed repræsenterer en ekspanderbar kommando: hvis ja, ekspanderes den, eller makroen kaldes. For ikke-ekspanderbare enheder `getxtoken()` beregner den en tokenværdi, og disse detaljer sendes videre til næste behandlingsstadie: den “store switch”, hvor ikke-ekspanderbare primtiver udføres og tegn sættes.
I det væsentlige er det via `getxtoken()` at alle ekspanderbare enheder “filtreres fra”, før de behandles i `maincontrol()`: dette resulterer i, at TeXs “store switch” kun behandler ikke-ekspanderbare primitive kommandoer.
Igen understreger vi, at ovenstående diagram er en forenkling, fordi andre dele af TeXs behandling også vil få tokens til at blive ekspanderet; for eksempel:
* når TeX leder (scanner) efter numeriske værdier, vil det udløse ekspansion i sin søgen efter heltal (ved at kalde `getxtoken()`) ;
* den primitive kommando `\romannumeral` forårsager ekspansion—se artiklen [Ekspansion ved hjælp af `\romannumeral`](https://www.texdev.net/2011/07/05/expansion-using-romannumeral/) for en nuanceret brug af dette faktum;
* Den `\edef` “(udvidet definition)” makrodefinitionskommando tvinger fuld ekspansion;
* TeX vil ekspandere tokens på visse punkter, når det behandler forordet til en `\halign` eller `\valign` (begge kommandoer er relateret til TeXs tabellægningsalgoritmer).
[Del 1](/latex/da/dybtgaende-artikler/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Del 2](/latex/da/dybtgaende-artikler/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Del 3](/latex/da/dybtgaende-artikler/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Del 4](/latex/da/dybtgaende-artikler/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Del 5](/latex/da/dybtgaende-artikler/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Del 6](/latex/da/dybtgaende-artikler/18-how-does-expandafter-work-a-detailed-study-of-consecutive-expandafter-commands.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/da/dybtgaende-artikler/22-how-does-expandafter-work-the-meaning-of-expansion.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.