> 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/no/dybdeartikler/22-how-does-expandafter-work-the-meaning-of-expansion.md).
# Hvordan fungerer \expandafter: Hva ekspansjon betyr
[Del 1](/latex/no/dybdeartikler/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Del 2](/latex/no/dybdeartikler/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Del 3](/latex/no/dybdeartikler/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Del 4](/latex/no/dybdeartikler/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Del 5](/latex/no/dybdeartikler/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Del 6](/latex/no/dybdeartikler/18-how-does-expandafter-work-a-detailed-study-of-consecutive-expandafter-commands.md)
## Introduksjon til TeXs begrep «ekspansjon»
Etter å ha gjennomgått [TeX-tokens og tokenlister](https://www.overleaf.com/learn/latex/Articles/\expandafter_TeX_tokens?preview=true), neste på listen vår over bakgrunnstemaer for `\expandafter` er TeXs begrep om *utvidelse*: den sentrale TeX-prosessen `\expandafter` er utformet for å arbeide med.
### Om utfordringen med å forklare ekspansjon...
For de fleste av oss kan TeXs begrep om ekspansjon, og årsakene/mekanismen(e) bak det, være forvirrende—de er ikke enkle å *fullt ut* forklare på en enkel og konsis måte. Mange av TeXs indre operasjoner/prosesser er sammenvevd på ganske komplekse måter, noe som kan skape utfordringer når man prøver å «dissekere» visse aspekter ved TeXs operasjoner: å forsøke å diskutere dem isolert fra programmet som helhet. Ekspansjon er definitivt et begrep som faller inn under den kategorien fordi det er et *grunnleggende* element i TeXs oppførsel, og dypt innvevd gjennom TeXs indre prosesser. Denne artikkelen forsøker imidlertid å konstruere en forklaring av ekspansjon, og tilbyr et grunnlag som leserne kan bygge videre på.
For å forklare TeXs ekspansjonsmekanisme går vi trinn for trinn, ser på en rekke beslektede/relevante emner, og setter dem sammen for å utvikle en forståelse av dette avgjørende elementet i TeXs oppførsel. Senere i artikkelen, og for den mer eventyrlystne leseren som liker detaljer, tar vi en titt inn i selve TeX, og oppsummerer den sentrale kildekoden som driver ekspansjonsprosessen.
### Hovedpunkter om TeX-tokens
Gjennom hele den følgende diskusjonen er det viktig å huske at TeX kan hente neste inndataelement fra to kilder:
1. **fysiske tekstfiler**: ved å generere *nye tokens* ved å lese/skanne tegn og kommandoer i disse filene, eller
2. **tokenlister**: ved å hente inndata ved å lese fra en liste over eksisterende, *forhåndsforberedte*, tokens lagret i TeXs minne.
Husk også at TeX bruker tokens som en praktisk måte å pent «pakke inn» informasjon om ethvert element (tegn eller kommando) det har lest inn.
Når TeX genererer *nye tokens* vil det, *på tidspunktet for tokenproduksjonen*, ha umiddelbar tilgang til informasjon om elementet hvis tokenverdi det beregner. Når TeX for eksempel genererer nye kommandotokens, beregner det først en verdi kalt `curcs` som gjør det mulig for TeX å slå opp informasjon om kommandoen tokenet det er i ferd med å produsere, representerer.
Men hvis TeX leser fra tokenlister (sekvenser av *lagrede tokens*) må det først «pakke ut» ethvert token i den listen før det kan avgjøre hva hvert token representerer. TeX kan for eksempel lese tokens som er lagret som en del av en makrodefinisjon: disse tokenene ville ha blitt generert fra tekst som for lengst er lest inn, konvertert til tokens og lagt bort. Tokentypen (tegn eller kommando) avgjør hva TeXs «utpakking» egentlig betyr:
* for *kommando-tokens* (tokenverdien er > 4095): beregn `curcs` via $$\text{curcs}=\text{token value}-4095$$ og bruk `curcs` for å slå opp informasjon om kommandoen;
* for *tegn-tokens* (tokenverdi < 4095): del tegn-tokenet opp i dets sammensatte par av (tegnkode, kategorikode).
### I begynnelsen...
For å begynne utforskningen av ekspansjon skal vi se på hvordan TeX-motorer klassifiserer, eller kategoriserer, mengden kommandoer de kan behandle. Inntil videre kan vi anta at «ekspanderbar» bare er en, ennå uforklart, «egenskap» ved en TeX-kommando.
### Begrepet «ekspanderbare» kommandoer
Alle satsprogrammer basert på TeX (TeX-«motorer») forstår to hoved«klasser» av kommandoer:
* kommandoer innebygd i selve den kjørbare motoren: de såkalte *primitivene*;
* kommandoer definert av brukeren: såkalte *makroer*.
TeX-motorer bruker også «å være ekspanderbar», en type kommando«oppførsel», som en mekanisme for å klassifisere alle kommandoer i to grupper:
* ekspanderbare kommandoer;
* ikke-ekspanderbare kommandoer.
Så vi kan betrakte mengden av alle kommandoer (primitiver pluss makroer) som klassifisert som vist i følgende figur:
Selv om vi ennå ikke vet hva ekspansjon/ekspanderbar egentlig betyr, er det mulig å se at:
* alle makroer er klassifisert som ekspanderbare kommandoer;
* noen primitive (innebygde) kommandoer er også klassifisert som ekspanderbare (det store flertallet er det ikke).
**Merknad om aktive tegn**: I tillegg til primitiver og makroer finnes det en tredje klasse av «ekspanderbare» elementer: aktive tegn—alle tegn som er tildelt kategorikode 13 regnes også som «ekspanderbare» fordi de behandles som «mini-makroer».
#### Hvordan vet TeX om en kommando er «ekspanderbar»?
Fra vår [diskusjon av TeX-tokens](https://www.overleaf.com/learn/latex/Articles/\expandafter_TeX_tokens?preview=true) vet vi at tokens ikke er annet enn heltall som TeX beregner og bruker til å «pakke inn» informasjon om et inndataelement: et tegn eller en kommando. Vi bemerket også at, gitt en hvilken som helst tokenverdi (heltall), kan TeX, om/når det er nødvendig, reversere tokeniseringsprosessen for å «pakke ut» et token og avdekke data om kommandoen eller tegnet det representerer.
Ved å bruke data som produseres når TeX oppretter et nytt token, eller data hentet ut fra et eksisterende token—f.eks. et som er lagret i en makro eller annen tokenliste—kan TeX sjekke sine interne datalagringstabeller for å finne detaljert informasjon om kommandoen (eller tegnet) som representeres av det tokenet. Følgende figur oppsummerer prosessen med å opprette et kommandotoken («pakking») og deretter, når TeX trenger informasjon, reversere prosessen («pakke ut» tokenet) for å få data om kommandoen representert av en bestemt tokenverdi.
### Kommandokoder
En del av informasjonen TeX lagrer om hver kommando (primitiv eller makro) er noe som kalles dens *kommandokode*: en heltallsverdi som TeX-motorer bruker (internt) til å klassifisere kommandoer—kommandoer med lignende oppførsel/funksjonalitet deler samme kommandokode.
**Merk**: For et enkelt, *ikke-aktive*, tegn, er kommandokoden dens *kategorikode* den som ble tildelt da det ble lest inn (skannet) av TeX. Merk også at, bortsett fra tegn, er kommandokoder rent interne i TeX: de er ikke tilgjengelige via makroer eller primitive kommandoer—for å se disse detaljene må du lese TeXs kildekode!
Her er noen eksempler på kommandokoder:
* `\hbox`, `\vbox`, `\vtop`, `\vcenter`, `\box` (og andre) er alle klassifisert som «boksopprettende» kommandoer og deler kommandokode 20;
* `\def`, `\edef`, `\gdef`, `\xdef` er alle «makrodefinisjons»-kommandoer og deler kommandokode 97;
* alle makroer klassifiseres med en av kommandokodene 111, 112, 113 eller 114: de ulike kommandokodene bestemmes av bruken av `\long` eller `\outer` når makroen defineres:
* 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 bruker også kommandokoder til å identifisere delmengden av kommandoer som klassifiseres som «ekspanderbare». For å gjøre det knytter TeX ekspanderbare kommandoer til kommandokodeverdier som overstiger terskelverdien 100 (verdien brukt av Knuths originale TeX, e-TeX og pdfTeX). Følgelig:
* *ikke-utvidbare* kommandoer (det store flertallet) har en kommandokode <= 100
* *ekspanderbare* kommandoer har en kommandokode > 100
Dermed vet TeX umiddelbart at den er ekspanderbar hvis det slår opp detaljene for en bestemt kommando og oppdager en kommandokode > 100. Alle makroer og et lite antall primitiver (innebygde kommandoer) tildeles en kommandokode som indikerer at de er ekspanderbare: men hvorfor bryr TeX seg om denne «ekspanderbar»-klassifiseringen? Som du kanskje mistenker, betyr det ganske enkelt at disse kommandoene er noe «spesielle»; dvs. at de kan underkastes TeXs prosess med *utvidelse*.
**Merknad (tegn)**: Med mindre et tegn er definert som aktivt (kategorikode 13), er alle tegn ikke-ekspanderbare. Aktive tegn kan betraktes som makroer i miniformat med én bokstav.
## Ja, ja, men hva er ekspansjon???
Vi bemerket at tokenverdier større enn 4095 brukes til å representere kommandoer; følgelig kan TeX, om/når nødvendig, «pakke ut» det tokenet for å få tilgang til informasjon om TeX-kommandoen som representeres av det tokenet. TeX kan slå opp denne kommandoens kommandokodeverdi for å avgjøre om den faller inn i den spesielle kategorien ekspanderbar. Men hva gjør TeX med den informasjonen, og hva betyr «å være ekspanderbar», dvs. ekspansjon, *egentlig*?
### Ekspansjon: Et generelt begrep for et sett av operasjoner
På visse punkter under TeXs behandling må det vite om et token representerer en ekspanderbar kommando:
* **Nei**: Hvis det kommandotokenet *ikke* ikke faller inn i den ekspanderbare kategorien, sender TeX det ganske enkelt videre til neste behandlingssteg.
* **Ja**: Hvis det kommandotokenet *ikke* faller inn i den ekspanderbare kategorien, kan du tenke på at TeX må gjøre noe som resulterer i at nettopp det tokenet «filtreres ut» ved å utføre en prosess som TeX kaller å «ekspandere det tokenet», eller å utføre ekspansjon.
I hovedsak innebærer ekspansjon at TeX *å fjerne* fjerner det tokenet fra inndataene og *å erstatte* erstatter det med tokens som oppstår fra «ekspansjonsprosessen» som er spesifikk for den kommandoen eller den gruppen kommandoer som deler samme kommandokode.
Det krever øvelse og erfaring å vite når TeX utfører, og ikke utfører, tokenekspansjon—side 215 i The TeXbook lister opp situasjonene der et ekspanderbart token ikke ekspanderes. Realiteten er at TeXs prosess for å utføre ekspansjon er kompleks og nyansert.
#### Hvilke kommandoer er ekspanderbare?
Hvis du ser på en liste over primitive (innebygde) kommandoer som TeX-motorer klassifiserer som ekspanderbare (f.eks. side 212–215 i The TeXbook), blir det tydelig at ekspansjon i praksis er et ganske generelt begrep som TeX bruker for å beskrive oppførselen til en noe eklektisk gruppe kommandoer. Resultatene av ekspansjon av en bestemt (ekspanderbar) kommando varierer, og vi kan se dette ved å liste opp et sett av ekspanderbare kommandoer—gruppert etter funksjonalitet. Den presise semantikken til enkeltkommandoer er ikke viktig her; det mest interessante er de generelle konsekvensene av handlingene deres—hva ekspansjonen deres faktisk *gjør eller oppnår*.
| **Kommando** | **Beskrivelse** | **Ekspansjonsoppførsel** |
| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| | En lagret sekvens av kommando-/tegn-tokens | I praksis betyr makroekspansjon å sette inn en liste med tokens som TeX skal lese. Dette innebærer:
- å lage tokenlister for eventuelle makroargumenter—den prosessen inkluderer å identifisere/oppslupe skilletegn-tokens;
- å hente fram en liste over lagrede tokens (makrodefinisjonen) og forberede innsetting av parametertokenene som ble opprettet i første steg.
Effektivt sett fjerner makro-tokenet fra inndataene og erstatter det med tokenene som finnes i definisjonen.
|
| | Endre rekkefølgen på ekspansjonen | Tokenfiltrering/-omstokking |
| | Hindre ekspansjon (ja, overraskende nok er det klassifisert som en ekspanderbar kommando) | Utsett ekspansjon (en slags tokenfiltrering) |
| \input, \endinput, \scantokens
| Knyttet til å lese inn en ny kilde til tokens via kildefiler—ja, `\scantokens` i denne kategorien på grunn av bruken av såkalte «pseudofiler» | Fungere 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
| Begynn et betinget uttrykk | Start token«filtrering»: avgjør hvilke av de følgende tokenene som skal behandles. |
| | Avslutt et betinget uttrykk | Stopp token«filtrering»: avgjør hvilke tokens som skal behandles |
| | Konstruer/generer et kommandotoken | Konverter en serie tokens til ett enkelt kommandotoken |
| \number, \romannumeral, \string, \meaning, \fontname, \jobname, \eTeXrevision
| Konverter noe til en sekvens av tokens | Generer noen tokens (som representerer en intern størrelse eller verdi) |
| \the, \unexpanded, \detokenize
| `\the` har ulike bruksområder, inkludert innsetting av tokens; `\detokenize` konverterer en tokenliste til en liste over tegn-tokens; `\unexpanded` forhindrer ekspansjon av tokens | Sett inn/generer noen tokens eller kontroller ekspansjonen |
| \topmark, \firstmark, \botmark, \splitfirstmark, \splitbotmark, \topmarks, \firstmarks, \botmarks, \splitfirstmarks, \splitbotmarks
| Kommandoer for tilgang til tokenlister som har spesialiserte bruksområder | Få tilgang til en kilde av lagrede tokens (tokenlister) |
Basert på listen ovenfor, er det mulig å trekke ut noen «generelle oppførselstrekk» fra denne samlingen av kommandoer—for å finjustere forståelsen vår av ekspansjon? Tilnærmet sett faller resultatene av å ekspandere en kommando inn under noen få nøkkelaktiviteter:
* tokengenerering
* tokeninnsetting
* tokenfiltrering
* endre/kontrollere ekspansjonen til neste token
### Og til slutt: betydningen av ekspansjon?
Vi kan betrakte ekspansjon av et kommandotoken (inkludert aktive tegn) som at TeX **å fjerne** fjerner det kommandotokenet fra inndataene og **å erstatte** erstatter det tokenet med andre tokens som oppstår fra ekspansjonsoppførselen: generering/innsetting av tokens, filtrering av tokens eller endring/kontroll av ekspansjonen til neste token. Når et token først er ekspandert, vil TeX fortsette å lese/behandle eventuelle tokens som måtte oppstå fra ekspansjonsprosessen. Nøyaktig når eller hvor TeX utfører ekspansjon er et helt annet spørsmål: på grunn av nyansene og kompleksiteten i TeXs behandling er det noe vi ikke kan håpe å dekke fullt ut i denne artikkelen, men vi kan gi en oversikt over TeXs viktigste inndata-behandlingsoppførsel.
## Ekspansjon og strukturen til TeX
Det beste måten å se hvordan/hvor TeX skiller mellom ekspanderbare og ikke-ekspanderbare kommandoer på, er sannsynligvis å se på TeXs kildekode.
Internt er TeX et ekstremt komplekst program; derfor er det upraktisk å forsøke en fullstendig beskrivelse av de mange nyanserte oppførselene som ligger i TeXs virkemåte. Som nevnt er nøyaktig når eller hvor TeX faktisk utfører ekspansjon mens det leser tokens, «ganske komplekst»; derfor forutsetter den følgende diskusjonen at TeX er i en tilstand som krever at ekspansjon finner sted. Situasjoner der TeX leser/oppretter tokens, men ikke utfører ekspansjon, inkluderer å opprette/lagre tokens for `\def` makrodefinisjonskommandoen eller å lagre tokens i en `\toks` register.
Følgende diagram gir en forenklet oversikt over kjerne-delene av TeXs struktur som håndterer inndata og behandling av tokens: målet er å fremheve måten ekspanderbare og ikke-ekspanderbare tokens blir «filtrert» under TeXs inndatabehandling. Programmeringsspråket C brukes til å beskrive de ulike nøkkelfunksjonene, men forhåpentligvis bør den grunnleggende strukturen være klar selv om du ikke er kjent med C.
### Forklaring av TeX-strukturdiagrammet
I grove trekk styres TeXs behandling av en funksjon kalt `maincontrol()` som Knuth i TeXs kildekode omtaler som «chief executive» og beskriver slik:
> «Vi kommer nå til `maincontrol` rutinen, som inneholder hovedbryteren som får alle de ulike delene av TeX til å gjøre sine ting, i riktig rekkefølge… dette er programmets store klimaks… Vi er nå ved navet i nettet, det sentrale nervesystemet som berører de fleste andre deler og binder dem sammen.»
Følgende beskrivelse er noe forenklet, men gir en «smak» av den underliggende strukturen i TeX-basert programvare: hvordan ekspanderbare kommandoer identifiseres («avskjæres») og filtreres ut under TeXs inndatabehandling.
I hovedsak bruker TeX, i den tidligste fasen av inndatabehandlingen, kommandokodeverdien til den aktuelle kommandoen (tokenet) for å oppdage ekspanderbare kommandoer (makroer, ekspanderbare primitiver og aktive tegn); hvis en slik identifiseres, blir slike kommandoer «avskåret» og «forbehandlet»—ved å bli ekspandert. Gjennom denne filtreringsprosessen (ekspansjon) fjerner TeX ekspanderbare kommandoer fra inndataene og erstatter dem med tokens som oppstår fra deres respektive ekspansjonsoppførsel. Når ekspansjonsprosessen er fullført, vil TeX lese eventuelle tokens som ble produsert av den ekspansjonen. Bare ikke-ekspanderbare elementer sendes videre til neste trinn i TeXs behandling: den «store bryteren» der TeX vil utføre alle ikke-ekspanderbare primitive kommandoer og sette tekst for tegn.
### Forstå maincontrol()
Den `maincontrol()` funksjonen inneholder en stor såkalt [switch-setning](https://en.wikipedia.org/wiki/Switch_statement)—Knuth kaller den «the big switch»—som TeX bruker til å utføre alle *ikke-utvidbare* primitive kommandoer: de med en kommandokode <=100.
For å utføre en bestemt kommando (eller et tegn) bruker denne «store bryteren» en kombinasjon av TeXs gjeldende modus:
* intern/yttervertikal modus, eller
* begrenset/avsnitts-horisontal modus, eller
* innebygd/visningsmatematikkmodus
*pluss* verdien av kommandokoden for hver primitiv eller tegn—kommandokoden til et *ikke-aktive* tegn er dets *kategorikode* verdi. For ordens skyld er alle de 6 modusene i TeX tildelt en heltallsverdi som TeX kan bruke til å lagre og gjenopprette gjeldende modus mens det veksler mellom å sette ulike konstruksjoner—matematikk, avsnitt, bokser og så videre. Her er heltallene som er tildelt TeXs ulike moduser:
| | | |
| ---------------------------- | ------------------------------------ | -------------- |
| **Modus** | **Betydning** | **Modusverdi** |
| Ytre vertikal | Mellom avsnitt (bygge sider) | 1 |
| Indre vertikal | Umiddelbart inne i en `\vbox{...}` | -1 |
| Horisontal | Ved satsing/bygging av avsnitt | 102 |
| Begrenset horisontal | Umiddelbart inne i en `\hbox{...}` | -102 |
| Visningsmatematikk | Satsing *visnings* likninger/formler | 203 |
| Innebygd (formel-)matematikk | Satsing *innebygd* likninger/formler | -203 |
Merk bruken av negative verdier for komplementet til de ulike modusene, slik som indre vs. ytre vertikal modus. Når kommandoer behandles i `maincontrol()`, bruker TeX absoluttverdien av gjeldende modus—dvs. ignorerer minustegnet. Så for eksempel, hvis TeX er i en av sine horisontale moduser og trenger å behandle et tegn med kategorikode 11, ville det bruke summen $$102 + 11 = 113$$ inne i sin «store bryter» til å forgrene seg til koden som behandler disse tegnene i en av de horisontale modusene (bygging av avsnitt eller inne i en `\hbox`).
#### Å få neste token
Den `maincontrol()` funksjonen kaller funksjonen `getxtoken()` for å få neste inndatatoken; deretter, `getxtoken()` kaller den den laveste inndatafunksjonen `getnext()`. Etter at `getnext()` har fullført arbeidet sitt, og satt verdien til sentrale *globale variabler*, `getxtoken()` tester om elementet som nettopp er lest inn representerer en makro eller en ekspanderbar primitiv.
Noen merknader om `getnext()` og `getxtoken()`:
* **`getnext()`**: dette er TeXs kjernefunksjon for inndata. Den leser og behandler tegn som mates inn fra en fysisk fil eller leser tokens fra en tokenliste. Merk at `getnext()` faktisk ikke beregner tokenverdier, men den setter en rekke viktige *globale* variabler (f.eks. kommandokoden og `curcs`) som brukes senere i behandlingen.
* **`getxtoken()`**: «get expanded token» bruker `getnext()` for å lese neste inndataelement. Deretter tester den kommandokoden til elementet som nettopp ble lest inn for å sjekke om det elementet representerer en ekspanderbar kommando: hvis ja, blir det ekspandert eller makroen kalles. For ikke-ekspanderbare elementer, `getxtoken()` beregner den en tokenverdi, og disse detaljene sendes videre til neste behandlingssteg: den «store bryteren» der ikke-ekspanderbare primitiver utføres og tegn settes.
I hovedsak er det via `getxtoken()` at alle ekspanderbare elementer blir «filtrert ut» før de behandles i `maincontrol()`: dette gjør at TeXs «store bryter» bare behandler ikke-ekspanderbare primitive kommandoer.
Igjen vil vi understreke at diagrammet ovenfor er en forenkling fordi andre deler av TeXs behandling også vil føre til at tokens ekspanderes; for eksempel:
* når TeX leter (skanner) etter numeriske verdier, vil det utløse ekspansjon i søket etter heltall (ved å kalle `getxtoken()`) ;
* den primitive kommandoen `\romannumeral` forårsaker ekspansjon—se artikkelen [Ekspansjon ved bruk av `\romannumeral`](https://www.texdev.net/2011/07/05/expansion-using-romannumeral/) for en nyansert bruk av det faktumet;
* Den `\edef` («utvidet definisjon») makrodefinisjonskommandoen tvinger fram full ekspansjon;
* TeX vil ekspandere tokens på visse punkter når det behandler preamblen til en `\halign` eller `\valign` (begge kommandoene er knyttet til TeXs algoritmer for tabellsatsing).
[Del 1](/latex/no/dybdeartikler/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Del 2](/latex/no/dybdeartikler/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Del 3](/latex/no/dybdeartikler/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Del 4](/latex/no/dybdeartikler/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Del 5](/latex/no/dybdeartikler/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Del 6](/latex/no/dybdeartikler/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/no/dybdeartikler/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.