> 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/it/articoli-approfonditi/22-how-does-expandafter-work-the-meaning-of-expansion.md).
# Come funziona \expandafter: il significato dell'espansione
[Parte 1](/latex/it/articoli-approfonditi/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Parte 2](/latex/it/articoli-approfonditi/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Parte 3](/latex/it/articoli-approfonditi/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Parte 4](/latex/it/articoli-approfonditi/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Parte 5](/latex/it/articoli-approfonditi/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Parte 6](/latex/it/articoli-approfonditi/18-how-does-expandafter-work-a-detailed-study-of-consecutive-expandafter-commands.md)
## Introducendo il concetto di «espansione» di TeX
Dopo aver esaminato [i token di TeX e le liste di token](https://www.overleaf.com/learn/latex/Articles/\expandafter_TeX_tokens?preview=true), il prossimo nella nostra lista di argomenti di contesto per `\\expandafter` è il concetto di espansione di TeX *espansione*: il processo fondamentale di TeX `\\expandafter` è progettato per funzionare con.
### Sulla sfida di spiegare l'espansione...
Per la maggior parte di noi, il concetto di espansione di TeX, e le ragioni/meccanismi che lo stanno dietro, possono essere confusi: non sono facili da *completamente* spiegare in modo semplice e conciso. Molte delle operazioni/processi interni di TeX sono interconnessi in modi piuttosto complessi, il che può presentare difficoltà quando si cerca di “dissezionare” certi aspetti delle operazioni di TeX: cercando di discuterli isolatamente dal programma nel suo insieme. L'espansione è certamente un concetto che rientra in questa categoria perché è un *fondamentale* elemento del comportamento di TeX, e profondamente incorporato in tutti i processi interni di TeX. Tuttavia, questo articolo cerca di costruire una spiegazione dell'espansione, offrendo una base su cui i lettori possono costruire.
Per spiegare il meccanismo di espansione di TeX procederemo passo per passo, esaminando una serie di argomenti correlati/rilevanti e mettendoli insieme per sviluppare una comprensione di questo elemento cruciale del comportamento di TeX. Più avanti nell'articolo, e per il lettore più intrepido che ama i dettagli, daremo uno sguardo all'interno di TeX stesso, riassumendo il codice sorgente chiave che guida il processo di espansione.
### Punti chiave sui token di TeX
Durante la discussione che segue è importante ricordare che TeX può ottenere il suo prossimo elemento di input da due fonti:
1. **file di testo fisici**: generando *nuovi token* leggendo/scansionando caratteri e comandi all'interno di quei file, oppure
2. **liste di token**: ottenendo l'input leggendo da un elenco di token esistenti, *preparati in anticipo*, memorizzati nella memoria di TeX.
Ricorda inoltre che TeX usa i token come un modo comodo per “impacchettare” ordinatamente le informazioni su qualsiasi elemento (carattere o comando) che abbia letto.
Quando TeX sta generando *nuovi token* esso avrà, *nel momento della produzione del token*, accesso immediato alle informazioni sull'elemento il cui valore di token sta calcolando. Per esempio, quando genera nuovi token di comando, TeX calcola prima un valore chiamato `curcs` che consente a TeX di cercare informazioni sul comando di cui sta per produrre il token.
Tuttavia, se TeX sta leggendo da liste di token (sequenze di *token memorizzati*) dovrebbe prima “disimballare” qualsiasi token in quella lista prima di poter determinare cosa rappresenti ciascun token. Per esempio, TeX potrebbe leggere token memorizzati come parte di una definizione di macro: quei token sarebbero stati generati da testo che da tempo è già stato letto, convertito in token e accantonato. Il tipo di token (carattere o comando) determina cosa significhi realmente il “disimballaggio” di TeX:
* per *token di comando* (il valore del token è > 4095): calcolare `curcs` tramite $$\text{curcs}=\text{token value}-4095$$ e usare `curcs` per cercare informazioni sul comando;
* per *token di carattere* (il valore del token è < 4095): separare il token di carattere nella sua coppia costituente di (codice del carattere, codice di categoria).
### All'inizio...
Per iniziare la nostra esplorazione dell'espansione esamineremo come i motori TeX classificano, o categorizzano, l'insieme dei comandi che possono elaborare. Per il momento, supponi che “espandibile” sia semplicemente una qualche “proprietà” di un comando TeX, ancora da spiegare.
### La nozione di comandi “espandibili”
Tutti i programmi di composizione tipografica basati su TeX (i “motori” TeX) comprendono due principali “classi” di comando:
* comandi incorporati nel motore eseguibile stesso: i cosiddetti *primitivi*;
* comandi definiti dall'utente: i cosiddetti *macro*.
I motori TeX usano anche l'“essere espandibile”, un tipo di “comportamento” dei comandi, come meccanismo per classificare tutti i comandi in due gruppi:
* comandi espandibili;
* comandi non espandibili.
Quindi possiamo considerare che l'insieme di tutti i comandi (primitive più macro) possa essere classificato come mostrato nella figura seguente:
Anche se non sappiamo ancora cosa significhino davvero espansione/espandibile, è possibile vedere che:
* tutte le macro sono classificate come comandi espandibili;
* alcuni comandi primitivi (incorporati) sono anch'essi classificati come espandibili (la stragrande maggioranza non lo è).
**Nota sui caratteri attivi**: Oltre alle primitive e alle macro esiste una terza classe di elemento “espandibile”: i caratteri attivi: qualsiasi carattere assegnato con codice di categoria 13 è anch'esso considerato “espandibile” perché viene elaborato come una “macro in miniatura”.
#### Come fa TeX a sapere se un comando è “espandibile”?
Dalla nostra [discussione sui token di TeX](https://www.overleaf.com/learn/latex/Articles/\expandafter_TeX_tokens?preview=true) sappiamo che i token non sono altro che interi che TeX calcola e usa per “impacchettare” informazioni su un elemento di input: un carattere o un comando. Abbiamo anche osservato che, dato un qualsiasi valore di token (intero), TeX può, se/quando necessario, invertire il processo di tokenizzazione per “disimballare” un token e rivelare dati sul comando o carattere che rappresenta.
Usando i dati prodotti quando TeX crea un nuovo token, o i dati estratti da un token esistente — per esempio uno memorizzato in una macro o in un'altra lista di token — TeX può controllare le sue tabelle interne di memorizzazione dei dati per trovare informazioni dettagliate sul comando (o carattere) rappresentato da quel token. La figura seguente riassume il processo di creazione di un token di comando (“impacchettamento”) e poi, quando TeX ha bisogno di alcune informazioni, la inversione del processo (“disimballaggio” del token) per ottenere dati sul comando rappresentato da un particolare valore di token.
### Codici di comando
Parte delle informazioni che TeX memorizza su ogni comando (primitivo o macro) è qualcosa chiamato il suo *codice di comando*: un valore intero che i motori TeX usano (internamente) per classificare i comandi: i comandi che hanno un comportamento/funzionalità simile condividono lo stesso codice di comando.
**Nota**: Per un singolo *non attivo*, carattere, il suo codice di comando è il *codice di categoria* che gli è stato assegnato nel momento in cui è stato letto (scansionato) da TeX. Nota inoltre che, tranne che per i caratteri, i codici di comando sono puramente interni a TeX: non sono accessibili tramite macro o comandi primitivi — per vedere quei dettagli dovrai leggere il codice sorgente di TeX!
Ecco alcuni esempi di codici di comando:
* `\hbox`, `\vbox`, `\vtop`, `\vcenter`, `\box` (e altri) sono tutti classificati come comandi di “creazione di box” e condividono il codice di comando 20;
* `\def`, `\edef`, `\gdef`, `\xdef` sono tutti comandi di “definizione di macro” e condividono il codice di comando 97;
* tutte le macro sono classificate con uno dei codici di comando 111, 112, 113 o 114: i diversi codici di comando sono determinati dall'uso di `\long` o `\outer` quando si definisce la macro:
* 111: codice di comando per una macro non-long, non-outer (ad es., `\def\foo{...}`)
* 112: codice di comando per una macro long, non-outer (ad es., `\long\def\foo{...}`)
* 113: codice di comando per una macro non-long, outer (ad es., `\outer\def\foo{...}`)
* 114: codice di comando per una macro long, outer (ad es., `\long\outer\def\foo{...}`)
TeX usa anche i codici di comando per identificare il sottoinsieme di comandi classificati come “espandibili”. Per farlo, TeX associa i comandi espandibili a valori di codice di comando che superano il valore soglia di 100 (il valore usato dal TeX originale di Knuth, e-TeX e pdfTeX). Di conseguenza:
* *non espandibili* i comandi (la stragrande maggioranza) hanno un codice di comando <= 100
* *espandibili* i comandi hanno un codice di comando > 100
Pertanto, se TeX cerca i dettagli di un particolare comando e rileva un codice di comando > 100, TeX sa immediatamente che è espandibile. Tutte le macro e un piccolo numero di primitive (comandi incorporati) vengono assegnate a un codice di comando che indica che sono espandibili: ma perché TeX si preoccupa di questa classificazione “espandibile”? Come puoi sospettare, significa semplicemente che quei comandi sono in qualche modo “speciali”; cioè, possono essere sottoposti al processo di TeX di *espansione*.
**Nota (caratteri)**: A meno che un carattere non sia stato definito come attivo (codice di categoria 13), tutti i caratteri non sono espandibili. I caratteri attivi possono essere considerati come “mini macro” di una sola lettera.
## Sì, sì, ma che cos'è l'espansione???
Abbiamo notato che i valori dei token maggiori di 4095 sono usati per rappresentare i comandi; di conseguenza, TeX può, se/quando necessario, “disimballare” quel token per accedere alle informazioni sul comando TeX rappresentato da quel token. TeX può cercare il valore del codice di comando di quel comando per determinare se rientra nella categoria speciale dell'essere espandibile. Ma che cosa fa TeX con quell'informazione e che cosa significa “essere espandibile”, cioè l'espansione, *davvero*?
### Espansione: termine generale per un insieme di operazioni
In certi punti durante l'elaborazione di TeX deve sapere se un token rappresenta un comando espandibile:
* **No**: Se quel token di comando *non* rientra nella categoria espandibile, TeX semplicemente lo “passa avanti” alla fase successiva dell'elaborazione.
* **Sì**: Se quel token di comando *di* rientra nella categoria espandibile, puoi pensare che TeX debba compiere un'azione che comporta il “filtrare via” quel particolare token eseguendo un processo che TeX definisce “espandere quel token”, oppure eseguire l'espansione.
In sostanza, l'espansione comporta che TeX *rimuova* quel token dal suo input e *lo sostituisca* con token che derivano dal “processo di espansione” specifico di quel comando o gruppo di comandi che condividono lo stesso codice di comando.
Serve pratica ed esperienza per sapere quando TeX sta, e quando non sta, eseguendo l'espansione dei token — la pagina 215 di The TeXbook elenca le situazioni in cui i token espandibili non vengono espansi. La realtà è che il processo di espansione di TeX è complesso e ricco di sfumature.
#### Quali comandi sono espandibili?
Se guardi un elenco di comandi primitivi (incorporati) che i motori TeX classificano come espandibili (ad es. le pagine 212–215 di The TeXbook) diventa evidente che, in pratica, l'espansione è un termine piuttosto generale che TeX usa per descrivere il comportamento di un gruppo di comandi alquanto eterogeneo. I risultati dell'espansione di un particolare comando (espandibile) variano effettivamente e possiamo vederlo elencando un insieme di comandi espandibili, raggruppati per funzionalità. La semantica precisa dei singoli comandi non è importante qui; ciò che più interessa sono le conseguenze generali delle loro azioni: ciò che la loro espansione effettivamente *fa o ottiene*.
| **Comando** | **Descrizione** | **Comportamento dell'espansione** |
| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| | Una sequenza memorizzata di token di comando/carattere | In effetti, l'espansione delle macro significa inserire una lista di token da leggere da parte di TeX. Questo comporta:
- creare liste di token per eventuali argomenti della macro: quel processo include l'identificazione/l'assorbimento dei token delimitatori;
- recuperare una lista di token memorizzati (la definizione della macro) e prepararsi a inserire (nella definizione della macro) i token parametro creati nel primo passo.
In pratica, l'espansione della macro rimuove il token della macro dall'input e lo sostituisce con i token contenuti nella definizione.
|
| | Cambia l'ordine dell'espansione | Filtraggio/riordino dei token |
| | Impedire l'espansione (sì, sorprendentemente è classificato come comando espandibile) | Rinviare l'espansione (in un certo senso filtraggio dei token) |
| \input, \endinput, \scantokens
| Correlato all'immissione di una nuova fonte di token tramite file sorgente — sì, `\scantokens` in questa categoria a causa del suo uso dei cosiddetti “pseudo-file” | Agire come fonte di nuovi token |
| \if, \ifcat, \ifnum, \ifdim, \ifodd, \ifvmode, \ifhmode, \ifmmode, \ifinner, \ifvoid, \ifhbox, \ifvbox, \ifx, \ifeof, \iftrue, \iffalse, \ifcase, \ifdefined, \ifcsname, \iffontchar
| Iniziare un'espressione condizionale | Iniziare il “filtraggio” dei token: decidere quali dei token seguenti elaborare. |
| | Terminare un'espressione condizionale | Interrompere il “filtraggio” dei token: decidere quali token elaborare |
| | Costruire/generare un token di comando | Convertire una serie di token in un singolo token di comando |
| \number, \romannumeral, \string, \meaning, \fontname, \jobname, \eTeXrevision
| Convertire qualcosa in una sequenza di token | Generare alcuni token (che rappresentano una quantità o un valore interno) |
| \the, \unexpanded, \detokenize
| `\the` ha vari usi, inclusa l'inserzione di token; `\detokenize` converte una lista di token in un elenco di token di carattere; `\unexpanded` impedisce l'espansione dei token | Inserire/generare alcuni token o controllare l'espansione |
| \topmark, \firstmark, \botmark, \splitfirstmark, \splitbotmark, \topmarks, \firstmarks, \botmarks, \splitfirstmarks, \splitbotmarks
| Comandi per accedere a liste di token che hanno usi specializzati | Accedere a una fonte di token memorizzati (liste di token) |
Sulla base dell'elenco sopra, è possibile ricavare alcuni “comportamenti generali” da questa raccolta di comandi — per affinare ulteriormente la nostra comprensione dell'espansione? Con una ragionevole approssimazione, i risultati dell'espansione di un comando rientrano in alcune attività chiave:
* generazione di token
* inserzione di token
* filtraggio di token
* cambiare/controllare l'espansione del token successivo
### E infine: il significato dell'espansione?
Possiamo considerare che l'espansione di un token di comando (inclusi i caratteri attivi) comporti che TeX **rimuova** quel token di comando dall'input e **lo sostituisca** quel token con altri token che derivano dal suo comportamento di espansione: generando/inserendo token, filtrando token o cambiando/controllando l'espansione del token successivo. Una volta che un token è stato espanso, TeX continuerebbe a leggere/elaborare eventuali token che potrebbero derivare dal processo di espansione. Esattamente quando o dove TeX eseguirà l'espansione è una domanda molto diversa: a causa delle sfumature e delle complessità dell'elaborazione di TeX è qualcosa che non possiamo sperare di affrontare completamente in questo articolo, ma possiamo fornire una panoramica del principale comportamento di elaborazione dell'input di TeX.
## Espansione e struttura di TeX
Si potrebbe dire che il modo migliore per vedere come/dove TeX distingue tra comandi espandibili e non espandibili è guardare il codice sorgente di TeX.
Internamente, TeX è un software estremamente complesso; di conseguenza, è poco pratico tentare una descrizione completa delle molte sfumature di comportamento insite nel funzionamento di TeX. Come detto, esattamente quando o dove TeX esegua effettivamente l'espansione mentre legge i token è “piuttosto complesso”; di conseguenza, la discussione seguente assume che TeX si trovi in uno stato che richiede che l'espansione abbia luogo. Le situazioni in cui TeX leggerebbe/creerebbe token, ma non eseguirebbe l'espansione, includono la creazione/memorizzazione di token per il `\def` comando di definizione di macro o la memorizzazione di token in un `\toks` registro.
Il diagramma seguente fornisce una panoramica semplificata delle parti fondamentali della struttura di TeX che si occupano dell'input e dell'elaborazione dei token: l'obiettivo è evidenziare il modo in cui i token espandibili e non espandibili vengono “filtrati” durante l'elaborazione dell'input di TeX. Il linguaggio di programmazione C viene usato per descrivere le varie funzioni chiave ma, auspicabilmente, la struttura di base dovrebbe essere chiara anche se non hai familiarità con il linguaggio C.
### Spiegazione del diagramma della struttura di TeX
In sintesi, l'elaborazione di TeX è guidata da una funzione chiamata `maincontrol()` che, nel codice sorgente di TeX, Knuth definisce il “chief executive” e descrive così:
> “Arriviamo ora alla routine `maincontrol` , che contiene l'interruttore principale che fa sì che tutte le varie parti di TeX facciano le loro cose, nell'ordine giusto... questo è il grande climax del programma... Ora siamo al centro della rete, il sistema nervoso centrale che tocca la maggior parte delle altre parti e le tiene insieme.”
La descrizione seguente è alquanto semplificata ma dà un “sapore” della struttura sottostante del software basato su TeX: come i comandi espandibili vengono identificati (“intercettati”) e filtrati durante l'elaborazione dell'input di TeX.
In sostanza, durante la prima fase dell'elaborazione dell'input di TeX, esso usa il valore del codice di comando del comando (token) corrente per rilevare i comandi espandibili (macro, primitive espandibili e caratteri attivi); se ne viene identificato uno, tali comandi vengono “intercettati” e “pre-elaborati” — tramite espansione. Attraverso questo processo di filtraggio (espansione) TeX rimuove i comandi espandibili dall'input e li sostituisce con token derivanti dal loro rispettivo comportamento di espansione. Una volta completato il processo di espansione, TeX leggerà eventuali token prodotti da quell'espansione. Solo gli elementi non espandibili vengono passati alla fase successiva dell'elaborazione di TeX: il “grande switch” dove TeX eseguirà tutti i comandi primitivi non espandibili e comporrà i caratteri.
### Comprendere maincontrol()
Il `maincontrol()` la funzione contiene un grande cosiddetto [istruzione switch](https://en.wikipedia.org/wiki/Switch_statement)—Knuth la chiama il “grande switch”— che TeX usa per eseguire tutti i *non espandibili* comandi primitivi: quelli con un codice di comando <=100.
Per eseguire un particolare comando (o carattere) questa istruzione “grande switch” usa una combinazione del modo corrente di TeX:
* modo verticale interno/esterno, oppure
* modo orizzontale ristretto/di paragrafo, oppure
* modo matematico in linea/di visualizzazione
*più* il valore del codice di comando per ogni primitiva o carattere — il codice di comando di un *non attivo* carattere è il suo *codice di categoria* valore. Per la cronaca, tutti e 6 i modi di TeX sono assegnati a un valore intero che può essere usato da TeX per salvare e ripristinare il suo modo corrente mentre passa tra la composizione di vari costrutti — matematica, paragrafi, box e così via. Ecco gli interi assegnati ai vari modi di TeX:
| | | |
| ----------------------------- | ------------------------------------------------- | ------------------- |
| **Modo** | **Significato** | **Valore del modo** |
| Verticale esterno | Tra i paragrafi (costruzione delle pagine) | 1 |
| Verticale interno | Immediatamente all'interno di un `\vbox{...}` | -1 |
| Orizzontale | Durante la composizione/costruzione dei paragrafi | 102 |
| Orizzontale ristretto | Immediatamente all'interno di un `\hbox{...}` | -102 |
| Matematica visualizzata | Composizione *visualizzata* equazioni/formule | 203 |
| Matematica in linea (formula) | Composizione *in linea* equazioni/formule | -203 |
Nota l'uso di valori negativi per il complemento dei vari modi, come il verticale interno rispetto a quello esterno. Quando elabora comandi in `maincontrol()`, TeX usa il valore assoluto del modo corrente — cioè, ignora il segno negativo. Quindi, per esempio, se TeX si trova in uno dei suoi modi orizzontali e deve elaborare un carattere con codice di categoria 11, userebbe la somma $$102 + 11 = 113$$ all'interno del suo “grande switch” per diramarsi verso il codice che elabora quei caratteri in uno dei due modi orizzontali (costruendo paragrafi o all'interno di un `\hbox`).
#### Ottenere il token successivo
Il `maincontrol()` la funzione chiama la funzione `getxtoken()` per ottenere il token di input successivo; a sua volta, `getxtoken()` chiama la funzione di input di livello più basso `getnext()`. Dopo che `getnext()` ha completato il suo lavoro e impostato il valore delle chiavi *variabili globali*, `getxtoken()` verifica se l'elemento appena letto rappresenta una macro o una primitiva espandibile.
Alcune note su `getnext()` e `getxtoken()`:
* **`getnext()`**: questa è la funzione di input principale di TeX. Legge ed elabora i caratteri in input da un file fisico oppure legge token da una lista di token. Nota che `getnext()` in realtà non calcola i valori dei token ma imposta una serie di chiavi *globali* variabili (ad es. il codice di comando e `curcs`) che vengono usate in seguito nell'elaborazione.
* **`getxtoken()`**: “get expanded token” usa `getnext()` per leggere il prossimo elemento di input. Poi verifica il codice di comando dell'elemento appena letto per controllare se quell'elemento rappresenta un comando espandibile: se sì, viene espanso o viene chiamata la macro. Per gli elementi non espandibili, `getxtoken()` calcola un valore di token e questi dettagli vengono passati alla fase successiva dell'elaborazione: il “grande switch” dove le primitive non espandibili vengono eseguite e i caratteri vengono composti.
In sostanza, è tramite `getxtoken()` che tutti gli elementi espandibili vengono “filtrati via” prima di essere elaborati in `maincontrol()`: ciò fa sì che il “grande switch” di TeX elabori solo comandi primitivi non espandibili.
Ancora una volta sottolineiamo che il diagramma sopra è una semplificazione perché anche altre aree dell'elaborazione di TeX provocheranno l'espansione dei token; per esempio:
* quando TeX cerca (scansiona) valori numerici attiverà l'espansione nella ricerca di interi (chiamando `getxtoken()`) ;
* il comando primitivo `\romannumeral` causa espansione — vedi l'articolo [Espansione usando `\romannumeral`](https://www.texdev.net/2011/07/05/expansion-using-romannumeral/) per un uso sfumato di questo fatto;
* Il `\edef` (macro di “definizione espansa”) il comando di definizione di macro forza l'espansione completa;
* TeX espanderà i token in certi punti quando elabora il preambolo di un `\halign` o `\valign` (entrambi i comandi sono collegati agli algoritmi di composizione delle tabelle di TeX).
[Parte 1](/latex/it/articoli-approfonditi/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Parte 2](/latex/it/articoli-approfonditi/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Parte 3](/latex/it/articoli-approfonditi/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Parte 4](/latex/it/articoli-approfonditi/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Parte 5](/latex/it/articoli-approfonditi/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Parte 6](/latex/it/articoli-approfonditi/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/it/articoli-approfonditi/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.