> 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/sv/fordjupade-artiklar/22-how-does-expandafter-work-the-meaning-of-expansion.md).
# Hur fungerar \expandafter: betydelsen av expansion
[Del 1](/latex/sv/fordjupade-artiklar/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Del 2](/latex/sv/fordjupade-artiklar/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Del 3](/latex/sv/fordjupade-artiklar/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Del 4](/latex/sv/fordjupade-artiklar/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Del 5](/latex/sv/fordjupade-artiklar/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Del 6](/latex/sv/fordjupade-artiklar/18-how-does-expandafter-work-a-detailed-study-of-consecutive-expandafter-commands.md)
## Introduktion till TeX:s koncept för ”expansion”
Efter att ha gått igenom [TeX-token och tokenlistor](https://www.overleaf.com/learn/latex/Articles/\expandafter_TeX_tokens?preview=true), nästa ämne på vår lista över bakgrundsämnen för `\expandafter` är TeX:s koncept för *expansion*: den centrala TeX-processen `\expandafter` är utformad för att arbeta med.
### Om utmaningen med att förklara expansion...
För de flesta av oss kan TeX:s koncept för expansion, och orsakerna/mekanismen bakom det, vara förvirrande — de är inte lätta att *helt* förklara på ett enkelt, koncist sätt. Många av TeX:s inre operationer/processer är sammanlänkade på ganska komplexa sätt, vilket kan skapa utmaningar när man försöker ”plocka isär” vissa aspekter av TeX:s verksamhet: att försöka diskutera dem isolerat från programmet som helhet. Expansion är verkligen ett begrepp som hör dit eftersom det är ett *grundläggande* element i TeX:s beteende och djupt inbäddat i TeX:s inre processer. Den här artikeln försöker dock bygga upp en förklaring av expansion och erbjuder en grund som läsarna kan bygga vidare på.
För att förklara TeX:s expansionsmekanism går vi steg för steg igenom ett antal relaterade/relevanta ämnen och pusslar ihop dem för att utveckla en förståelse för denna avgörande del av TeX:s beteende. Längre fram i artikeln, och för den mer äventyrlige läsaren som gillar detaljer, tittar vi in i själva TeX och sammanfattar den centrala källkoden som driver expansionsprocessen.
### Viktiga punkter om TeX-token
Under den följande diskussionen är det viktigt att komma ihåg att TeX kan hämta sitt nästa indataelement från två källor:
1. **fysiska textfiler**: generera *nya tokens* genom att läsa/scanna tecken och kommandon i dessa filer, eller
2. **tokenlistor**: få indata genom att läsa från en lista över befintliga, *förberedda*, token lagrade i TeX:s minne.
Kom också ihåg att TeX använder token som ett bekvämt sätt att snyggt ”paketera” information om varje element (tecken eller kommando) som det har läst in.
När TeX genererar *nya tokens* kommer det, *i ögonblicket då tokenen skapas*, ha omedelbar åtkomst till information om det element vars tokenvärde det beräknar. Till exempel, när nya kommando-token genereras, beräknar TeX först ett värde som kallas `curcs` som gör det möjligt för TeX att slå upp information om det kommando vars token det är på väg att producera.
Men om TeX läser från tokenlistor (sekvenser av *lagrade token*) skulle det först behöva ”packa upp” varje token i den listan innan det kan avgöra vad varje token representerar. Till exempel kan TeX läsa token som lagrats som en del av en makrodefinition: dessa token skulle ha genererats från text som för länge sedan har lästs in, konverterats till token och lagrats undan. Tokentypen (tecken eller kommando) avgör vad TeX:s ”uppackning” egentligen betyder:
* för *kommandotoken* (tokenvärde > 4095): beräkna `curcs` via $$\text{curcs}=\text{token value}-4095$$ och använd `curcs` för att slå upp information om kommandot;
* för *tecken-token* (tokenvärde < 4095): dela upp tecken-token i dess beståndsdelar (teckenkod, kategori-kod).
### I början...
För att börja vår utforskning av expansion ska vi titta på hur TeX-motorer klassificerar, eller kategoriserar, mängden kommandon de kan bearbeta. För tillfället antar vi att ”expanderbar” bara är en, ännu oförklarad, ”egenskap” hos ett TeX-kommando.
### Begreppet ”expanderbara” kommandon
Alla TeX-baserade sättningsprogram (TeX-”motorer”) förstår två huvud-”klasser” av kommandon:
* kommandon inbyggda i själva den körbara motorn: de så kallade *primitiver*;
* kommandon som definieras av användaren: så kallade *makron*.
TeX-motorer använder också ”att vara expanderbar”, en typ av kommandobeteende, som en mekanism för att klassificera alla kommandon i två grupper:
* expanderbara kommandon;
* icke-expanderbara kommandon.
Så vi kan betrakta mängden av alla kommandon (primitiver plus makron) som klassificerad enligt följande bild:
Även om vi ännu inte vet vad expansion/expanderbar egentligen betyder, går det att se att:
* alla makron klassificeras som expanderbara kommandon;
* vissa primitiva (inbyggda) kommandon klassificeras också som expanderbara (de allra flesta gör det inte).
**Notis om aktiva tecken**: Förutom primitiver och makron finns en tredje klass av ”expanderbara” element: aktiva tecken — alla tecken som tilldelats kategori-kod 13 betraktas också som ”expanderbara” eftersom de behandlas som ”minimakron”.
#### Hur vet TeX om ett kommando är ”expanderbart”?
Från vår [diskussion om TeX-token](https://www.overleaf.com/learn/latex/Articles/\expandafter_TeX_tokens?preview=true) vet vi att token inte är något mer än heltal som TeX beräknar och använder för att ”paketera” information om ett indataelement: ett tecken eller ett kommando. Vi noterade också att, givet vilket tokenvärde (heltal) som helst, kan TeX, om/när det behövs, vända tokeniseringen och ”packa upp” en token för att avslöja data om det kommando eller tecken den representerar.
Med hjälp av data som produceras när TeX skapar en ny token, eller data som extraheras från en befintlig token — t.ex. en som lagras i ett makro eller en annan tokenlista — kan TeX kontrollera sina interna tabeller för datalagring för att hitta detaljerad information om det kommando (eller tecken) som representeras av den tokenen. Följande bild sammanfattar processen att skapa en kommando-token (”paketering”) och sedan, när TeX behöver viss information, vända processen (”packa upp” tokenen) för att få fram data om det kommando som representeras av ett visst tokenvärde.
### Kommandokoder
En del av informationen som TeX lagrar om varje kommando (primitiv eller makro) är något som kallas dess *kommandokod*: ett heltalsvärde som TeX-motorer använder (internt) för att klassificera kommandon — kommandon som har liknande beteende/funktionalitet delar samma kommandokod.
**Obs**: För ett enskilt, *icke-aktiva*, tecken, är dess kommandokod *kategorikod* som tilldelades när det lästes in (scannades) av TeX. Observera också att, med undantag för tecken, kommandokoder är helt interna i TeX: de är inte åtkomliga via makron eller primitiva kommandon — för att se dessa detaljer måste du läsa TeX:s källkod!
Här är några exempel på kommandokoder:
* `\hbox`, `\vbox`, `\vtop`, `\vcenter`, `\box` (och andra) klassificeras alla som kommandon för ”boxskapande” och delar kommandokod 20;
* `\def`, `\edef`, `\gdef`, `\xdef` är alla kommandon för ”makrodefinition” och delar kommandokod 97;
* alla makron klassificeras med någon av kommandokoderna 111, 112, 113 eller 114: de olika kommandokoderna bestäms av användningen av `\long` eller `\outer` när makrot definieras:
* 111: kommandokod för ett icke-long, icke-outer makro (t.ex., `\def\foo{...}`)
* 112: kommandokod för ett long, icke-outer makro (t.ex., `\long\def\foo{...}`)
* 113: kommandokod för ett icke-long, outer makro (t.ex., `\outer\def\foo{...}`)
* 114: kommandokod för ett long, outer makro (t.ex., `\long\outer\def\foo{...}`)
TeX använder också kommandokoder för att identifiera den delmängd av kommandon som klassificeras som ”expanderbara”. För att göra det kopplar TeX expanderbara kommandon till kommandokodvärden som överstiger tröskelvärdet 100 (det värde som används av Knuths ursprungliga TeX, e-TeX och pdfTeX). Följaktligen:
* *icke-expanderbara* kommandon (de allra flesta) har en kommandokod <= 100
* *expanderbara* kommandon har en kommandokod > 100
Därför, om TeX slår upp detaljerna för ett visst kommando och upptäcker en kommandokod > 100, vet TeX omedelbart att det är expanderbart. Alla makron och ett litet antal primitiver (inbyggda kommandon) tilldelas en kommandokod som anger att de är expanderbara: men varför bryr sig TeX om denna klassificering som ”expanderbar”? Som du kanske anar betyder det helt enkelt att dessa kommandon är något ”speciella”; dvs. de kan underkastas TeX:s process för *expansion*.
**Observera (tecken)**: Om inte ett tecken har definierats som aktivt (kategori-kod 13) är alla tecken icke-expanderbara. Aktiva tecken kan betraktas som enbokstavs-”minimakron”.
## Ja, ja, men vad är expansion???
Vi noterade att tokenvärden större än 4095 används för att representera kommandon; följaktligen kan TeX, om/när det behövs, ”packa upp” den tokenen för att få åtkomst till information om det TeX-kommando som representeras av tokenen. TeX kan slå upp kommandots kommandokodvärde för att avgöra om det faller inom den särskilda kategorin att vara expanderbart. Men vad gör TeX med den informationen och vad innebär ”att vara expanderbar”, dvs. expansion, *egentligen*?
### Expansion: en allmän term för en uppsättning operationer
Vid vissa punkter under TeX:s bearbetning behöver det veta om en token representerar ett expanderbart kommando:
* **Nej**: Om den kommando-tokenen *gör inte* tillhör den expanderbara kategorin, skickar TeX helt enkelt vidare den till nästa bearbetningssteg.
* **Ja**: Om den kommando-tokenen *gör* tillhör den expanderbara kategorin, kan man tänka sig att TeX behöver vidta en åtgärd som resulterar i att just den tokenen ”filtreras bort” genom att utföra en process som TeX kallar att ”expandera den tokenen”, eller att utföra expansion.
I grund och botten innebär expansion att TeX *att ta bort* tar bort den tokenen från sin indata och *att ersätta* ersätter den med token som uppstår från den ”expansionsprocess” som är specifik för det kommandot eller den grupp av kommandon som delar samma kommandokod.
Det krävs övning och erfarenhet för att veta när TeX utför, och inte utför, tokenexpansion — sida 215 i The TeXbook listar de situationer då expanderbara token inte expanderas. Verkligheten är att TeX:s process för att utföra expansion är komplex och nyanserad.
#### Vilka kommandon är expanderbara?
Om du tittar på en lista över primitiva (inbyggda) kommandon som TeX-motorer klassificerar som expanderbara (t.ex. sidorna 212–215 i The TeXbook) blir det tydligt att expansion i praktiken är en ganska allmän term som TeX använder för att beskriva beteendet hos en ganska eklektisk grupp av kommandon. Resultatet av expansionen av ett visst (expanderbart) kommando varierar, och vi kan se detta genom att lista en uppsättning expanderbara kommandon — grupperade efter deras funktionalitet. Den exakta semantiken för enskilda kommandon är inte viktig här; det som är mest intressant är de allmänna konsekvenserna av deras handlingar — vad deras expansion faktiskt *gör eller uppnår*.
| **kommando** | **Beskrivning** | **Expansionsbeteende** |
| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| | En lagrad sekvens av kommando-/tecken-token | I praktiken innebär makroexpansion att en lista med token infogas för TeX att läsa. Detta innebär:
- att skapa tokenlistor för alla makroargument — den processen inkluderar att identifiera/absorbera avgränsartoken;
- att hämta en lista med lagrade token (makrodefinitionen) och förbereda insättning (i makrodefinitionen) av de parametertoken som skapades i det första steget.
I praktiken tar makrotokenen bort bort från indata och ersätter den med token som finns i definitionen.
|
| | Ändra expansionsordningen | Tokenfiltrering/-omordning |
| | Förhindra expansion (ja, överraskande nog klassificeras det som ett expanderbart kommando) | Fördröj expansion (någon sorts tokenfiltrering) |
| \input, \endinput, \scantokens
| Relaterat till att mata in en ny tokenkälla via källfiler — ja, `\scantokens` i denna kategori på grund av dess användning av så kallade ”pseudofiler” | Fungera som en källa till nya token |
| \if, \ifcat, \ifnum, \ifdim, \ifodd, \ifvmode, \ifhmode, \ifmmode, \ifinner, \ifvoid, \ifhbox, \ifvbox, \ifx, \ifeof, \iftrue, \iffalse, \ifcase, \ifdefined, \ifcsname, \iffontchar
| Inleda ett villkorligt uttryck | Starta token-”filtrering”: avgöra vilka av följande token som ska bearbetas. |
| | Avsluta ett villkorligt uttryck | Stoppa token-”filtreringen”: avgöra vilka token som ska bearbetas |
| | Konstruera/generera en kommando-token | Konvertera en serie token till en enda kommando-token |
| \number, \romannumeral, \string, \meaning, \fontname, \jobname, \eTeXrevision
| Konvertera något till en sekvens av token | Generera vissa token (som representerar en intern storhet eller ett värde) |
| \the, \unexpanded, \detokenize
| `\the` har olika användningsområden, inklusive insättning av token; `\detokenize` konverterar en tokenlista till en lista med tecken-token; `\unexpanded` förhindrar expansion av token | Infoga/generera vissa token eller kontrollera expansion |
| \topmark, \firstmark, \botmark, \splitfirstmark, \splitbotmark, \topmarks, \firstmarks, \botmarks, \splitfirstmarks, \splitbotmarks
| Kommandon för åtkomst till tokenlistor som har specialiserade användningsområden | Få åtkomst till en källa av lagrade token (tokenlistor) |
Baserat på listan ovan, är det möjligt att extrahera några ”generella beteenden” från denna samling kommandon — för att ytterligare förfina vår förståelse av expansion? Med god approximation kan resultaten av att expandera ett kommando delas in i några få huvudaktiviteter:
* tokengenerering
* tokeninsättning
* tokenfiltrering
* ändra/styra expansionen av nästa token
### Och slutligen: betydelsen av expansion?
Vi kan betrakta expansionen av en kommando-token (inklusive aktiva tecken) som att TeX **att ta bort** tar bort den kommando-tokenen från indata och **att ersätta** ersätter den tokenen med andra token som uppstår ur dess expansionsbeteende: att generera/infoga token, filtrera token eller ändra/styra expansionen av nästa token. När en token väl har expanderats fortsätter TeX att läsa/bearbeta alla token som kan uppstå från expansionsprocessen. Exakt när eller var TeX utför expansion är en helt annan fråga: på grund av nyanserna och komplexiteten i TeX:s bearbetning är det något vi inte kan hoppas på att helt behandla i denna artikel, men vi kan ge en översikt över TeX:s huvudsakliga indata-beteende.
## Expansion och TeX:s struktur
Det bästa sättet att se hur/var TeX skiljer mellan expanderbara och icke-expanderbara kommandon är utan tvekan att titta på TeX:s källkod.
Internt är TeX en extremt komplex programvara; därför är det opraktiskt att försöka ge en fullständig beskrivning av de många nyanserade beteenden som är inbyggda i TeX:s funktion. Som nämnts är det ”ganska komplext” exakt när eller var TeX faktiskt utför expansion när det läser token; därför antar följande diskussion att TeX befinner sig i ett tillstånd som kräver att expansion sker. Situationer där TeX skulle läsa/skapa token men inte utföra expansion inkluderar att skapa/lagra token för `\def` makrodefinitionskommandot eller lagra token i ett `\toks` register.
Följande diagram ger en förenklad översikt över de centrala delarna av TeX:s struktur som hanterar indata och bearbetning av token: målet är att belysa hur expanderbara och icke-expanderbara token ”filtreras” under TeX:s indatabearbetning. Programmeringsspråket C används för att beskriva de olika nyckelfunktionerna, men förhoppningsvis bör den grundläggande strukturen vara tydlig även om du inte är bekant med C-språket.
### Förklaring av TeX-strukturdiagrammet
Översiktligt drivs TeX:s bearbetning av en funktion som kallas `maincontrol()` som i TeX:s källkod av Knuth kallas ”chief executive” och beskrivs så här:
> ”Vi kommer nu till `maincontrol` rutinen, som innehåller huvudomkopplaren som får alla de olika delarna av TeX att göra sina saker, i rätt ordning… detta är programmets stora klimax… Vi är nu vid nätets nav, det centrala nervsystemet som berör de flesta andra delar och binder samman dem.”
Följande beskrivning är något förenklad men ger en ”känsla” för den underliggande strukturen i TeX-baserad programvara: hur expanderbara kommandon identifieras (”fångas upp”) och filtreras bort under TeX:s indatabearbetning.
I grund och botten använder TeX, under det tidigaste stadiet av indatabearbetningen, värdet på kommandokoden för det aktuella kommandot (tokenen) för att upptäcka expanderbara kommandon (makron, expanderbara primitiver och aktiva tecken); om ett sådant identifieras, ”fångas” dessa kommandon upp och ”förbearbetas” — genom att expanderas. Genom denna filtreringsprocess (expansion) tar TeX bort expanderbara kommandon från indata och ersätter dem med token som uppstår ur deras respektive expansionsbeteende. När expansionsprocessen är klar läser TeX alla token som producerats från den expansionen. Endast icke-expanderbara element släpps vidare till nästa steg i TeX:s bearbetning: den ”stora switchen” där TeX exekverar alla icke-expanderbara primitiva kommandon och sätter tecken.
### Förstå maincontrol()
Den `maincontrol()` funktionen innehåller en stor så kallad [switch-sats](https://en.wikipedia.org/wiki/Switch_statement)—Knuth kallar den ”stora switchen” — som TeX använder för att utföra alla *icke-expanderbara* primitiva kommandon: de med en kommandokod <=100.
För att utföra ett visst kommando (eller tecken) använder denna ”stora switch”-sats en kombination av TeX:s aktuella läge:
* inre/yttre vertikalläge, eller
* begränsat/horisontellt styckeläge, eller
* inline-/displaymatematikläge
*plus* värdet på kommandokoden för varje primitivt kommando eller tecken — kommandokoden för ett *icke-aktiva* teckens *kategorikod* värde. För ordningens skull tilldelas alla TeX:s 6 lägen ett heltalsvärde som kan användas av TeX för att spara och återställa sitt aktuella läge medan det växlar mellan sättning av olika konstruktioner — matematik, stycken, boxar och så vidare. Här är de heltal som tilldelats TeX:s olika lägen:
| | | |
| --------------------------- | ------------------------------------------ | -------------- |
| **Läge** | **Betydelse** | **Lägesvärde** |
| Yttre vertikalläge | Mellan stycken (bygger sidor) | 1 |
| Inre vertikalläge | Omedelbart inuti en `\vbox{...}` | -1 |
| Horisontellt läge | När stycken sätts/byggs | 102 |
| Begränsat horisontellt läge | Omedelbart inuti en `\hbox{...}` | -102 |
| Displaymatematik | Sättning av *visnings* ekvationer/formler | 203 |
| Inline-(formel)matematik | Sättning av *radbunden* ekvationer/formler | -203 |
Observera användningen av negativa värden för komplementet till de olika lägena, såsom inre kontra yttre vertikalläge. När kommandon bearbetas i `maincontrol()`, använder TeX absolutbeloppet av det aktuella läget — dvs. ignorerar minustecknet. Så, till exempel, om TeX befinner sig i något av sina horisontella lägen och behöver bearbeta ett tecken med kategori-kod 11, skulle det använda summan $$102 + 11 = 113$$ i sin ”stora switch” för att grena av till den kod som bearbetar dessa tecken i antingen horisontellt läge (bygger stycken eller inne i en `\hbox`).
#### Hämta nästa token
Den `maincontrol()` funktionen anropar funktionen `getxtoken()` för att hämta nästa indatatoken; i sin tur `getxtoken()` anropar den lägsta indatafunktionen `getnext()`. Efter `getnext()` har slutfört sitt arbete och satt värdet för viktiga *globala variabler*, `getxtoken()` testar om det nyligen inlästa elementet representerar ett makro eller en expanderbar primitiv.
Några noteringar om `getnext()` och `getxtoken()`:
* **`getnext()`**: detta är TeX:s centrala indatafunktion. Den läser och bearbetar tecken inmatade från en fysisk fil eller läser token från en tokenlista. Observera att `getnext()` faktiskt inte beräknar tokenvärden men den sätter ett antal viktiga *globala* variabler (t.ex. kommandokoden och `curcs`) som används senare i bearbetningen.
* **`getxtoken()`**: ”get expanded token” använder `getnext()` för att läsa nästa indatapost. Den testar sedan kommandokoden för det nyligen inlästa elementet för att kontrollera om elementet representerar ett expanderbart kommando: i så fall expanderas det eller så anropas makrot. För icke-expanderbara element, `getxtoken()` beräknas ett tokenvärde och dessa detaljer skickas vidare till nästa bearbetningssteg: den ”stora switchen” där icke-expanderbara primitiver exekveras och tecken sätts.
I grund och botten är det via `getxtoken()` som alla expanderbara element ”filtreras bort” innan de bearbetas i `maincontrol()`: detta gör att TeX:s ”stora switch” endast bearbetar icke-expanderbara primitiva kommandon.
Återigen betonar vi att diagrammet ovan är en förenkling eftersom andra delar av TeX:s bearbetning också kommer att få token att expanderas; till exempel:
* när TeX letar (scannar) efter numeriska värden utlöser det expansion i sin sökning efter heltal (genom att anropa `getxtoken()`) ;
* det primitiva kommandot `\romannumeral` orsakar expansion — se artikeln [Expansion med `\romannumeral`](https://www.texdev.net/2011/07/05/expansion-using-romannumeral/) för en nyanserad användning av det faktumet;
* Den `\edef` (”expanderad definition”) makrodefinitionskommandot tvingar fram full expansion;
* TeX expanderar token vid vissa punkter när det bearbetar preambeln till en `\halign` eller `\valign` (båda kommandona är relaterade till TeX:s algoritmer för tabellsättning).
[Del 1](/latex/sv/fordjupade-artiklar/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Del 2](/latex/sv/fordjupade-artiklar/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Del 3](/latex/sv/fordjupade-artiklar/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Del 4](/latex/sv/fordjupade-artiklar/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Del 5](/latex/sv/fordjupade-artiklar/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Del 6](/latex/sv/fordjupade-artiklar/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/sv/fordjupade-artiklar/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.