> 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/id/artikel-mendalam/22-how-does-expandafter-work-the-meaning-of-expansion.md).
# Bagaimana \expandafter bekerja: Arti ekspansi
[Bagian 1](/latex/id/artikel-mendalam/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Bagian 2](/latex/id/artikel-mendalam/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Bagian 3](/latex/id/artikel-mendalam/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Bagian 4](/latex/id/artikel-mendalam/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Bagian 5](/latex/id/artikel-mendalam/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Bagian 6](/latex/id/artikel-mendalam/18-how-does-expandafter-work-a-detailed-study-of-consecutive-expandafter-commands.md)
## Memperkenalkan konsep “ekspansi” TeX
Setelah meninjau [token TeX dan daftar token](https://www.overleaf.com/learn/latex/Articles/\expandafter_TeX_tokens?preview=true), berikutnya dalam daftar topik latar belakang kita untuk `\expandafter` adalah konsep TeX tentang *ekspansi*: proses inti TeX `\expandafter` dirancang untuk bekerja dengan.
### Tentang tantangan menjelaskan ekspansi...
Bagi kebanyakan dari kita, konsep ekspansi TeX, dan alasan/mekanisme di baliknya, bisa membingungkan—tidak mudah untuk *sepenuhnya* menjelaskannya secara sederhana dan ringkas. Banyak operasi/proses internal TeX saling terkait dengan cara yang cukup kompleks, yang dapat menimbulkan tantangan saat mencoba “membedah” aspek tertentu dari operasi TeX: mencoba membahasnya secara terpisah dari program secara keseluruhan. Ekspansi tentu saja merupakan konsep yang termasuk dalam kategori itu karena ia adalah sebuah *mendasar* elemen perilaku TeX, dan tertanam sangat dalam di seluruh proses internal TeX. Namun, artikel ini berupaya menyusun penjelasan tentang ekspansi, menawarkan landasan yang dapat dibangun oleh pembaca.
Untuk menjelaskan mekanisme ekspansi TeX, kita akan melangkah selangkah demi selangkah, meninjau berbagai topik terkait/relevan, lalu menyusunnya bersama untuk mengembangkan pemahaman tentang elemen krusial dari perilaku TeX ini. Nanti dalam artikel ini, dan bagi pembaca yang lebih berani dan menyukai detail, kita akan melihat ke dalam TeX sendiri, merangkum kode sumber utama yang menggerakkan proses ekspansi.
### Poin-poin penting tentang token TeX
Sepanjang pembahasan berikut, penting untuk diingat bahwa TeX dapat memperoleh item input berikutnya dari dua sumber:
1. **berkas teks fisik**: menghasilkan *token baru* dengan membaca/men-scan karakter dan perintah di dalam berkas tersebut, atau
2. **daftar token**: memperoleh input dengan membaca dari daftar yang sudah ada, *yang telah disiapkan sebelumnya*, token yang disimpan dalam memori TeX.
Ingat juga bahwa TeX menggunakan token sebagai cara yang praktis untuk “mengemas” informasi tentang setiap item (karakter atau perintah) yang telah dibacanya.
Saat TeX menghasilkan *token baru* ia akan, *pada saat produksi*token, memiliki akses langsung ke informasi tentang item yang nilai tokennya sedang dihitung. Misalnya, saat menghasilkan token perintah baru, TeX pertama-tama menghitung nilai yang disebut `curcs` yang memungkinkan TeX mencari informasi tentang perintah yang tokennya akan dibuat.
Namun, jika TeX membaca dari daftar token (rangkaian dari *token tersimpan*) ia harus terlebih dahulu “membongkar” token apa pun dalam daftar itu sebelum dapat menentukan apa yang diwakili setiap token. Misalnya, TeX bisa saja membaca token yang disimpan sebagai bagian dari definisi makro: token-token itu telah dihasilkan dari teks yang sudah lama dibaca, diubah menjadi token, dan disimpan. Jenis token (karakter atau perintah) menentukan apa arti sebenarnya dari “pembongkaran” oleh TeX:
* untuk *token perintah* (nilai token > 4095): hitung `curcs` melalui $$\text{curcs}=\text{token value}-4095$$ dan gunakan `curcs` untuk mencari informasi tentang perintah;
* untuk *token karakter* (nilai token < 4095): pecah token karakter menjadi pasangan penyusunnya (kode karakter, kode kategori).
### Pada awalnya...
Untuk memulai eksplorasi kita tentang ekspansi, kita akan melihat bagaimana mesin TeX mengklasifikasikan, atau mengkategorikan, kumpulan perintah yang dapat mereka proses. Untuk saat ini, anggaplah bahwa “expandable” hanyalah suatu “sifat” perintah TeX yang belum dijelaskan.
### Gagasan tentang perintah “expandable”
Semua program penyusunan huruf berbasis TeX (mesin TeX) memahami dua “kelas” utama perintah:
* perintah yang tertanam di dalam mesin eksekusi itu sendiri: yang disebut *primitif*;
* perintah yang ditentukan oleh pengguna: yang disebut *makro*.
Mesin TeX juga menggunakan “bersifat expandable”, suatu jenis “perilaku” perintah, sebagai mekanisme untuk mengklasifikasikan semua perintah ke dalam dua kelompok:
* perintah expandable;
* perintah non-expandable.
Jadi kita dapat menganggap bahwa himpunan semua perintah (primitif plus makro) dapat diklasifikasikan seperti yang ditunjukkan pada gambar berikut:
Meskipun kita belum tahu apa sebenarnya arti ekspansi/expandable, kita dapat melihat bahwa:
* semua makro diklasifikasikan sebagai perintah expandable;
* sebagian perintah primitif (bawaan) juga diklasifikasikan sebagai expandable (sebagian besar tidak).
**Catatan tentang karakter aktif**: Selain primitif dan makro, ada kelas ketiga item “expandable”: karakter aktif—setiap karakter yang diberi kode kategori 13 juga dianggap “expandable” karena diproses sebagai “makro mini”.
#### Bagaimana TeX tahu apakah suatu perintah “expandable”?
Dari [pembahasan tentang token TeX](https://www.overleaf.com/learn/latex/Articles/\expandafter_TeX_tokens?preview=true) kita tahu bahwa token tidak lain hanyalah bilangan bulat yang dihitung dan digunakan TeX untuk “mengemas” informasi tentang item input: karakter atau perintah. Kita juga mencatat bahwa, untuk nilai token (bilangan bulat) apa pun, TeX dapat, jika/dan ketika diperlukan, membalik proses tokenisasi untuk “membongkar” token dan mengungkap data tentang perintah atau karakter yang diwakilinya.
Dengan menggunakan data yang dihasilkan saat TeX membuat token baru, atau data yang diekstrak dari token yang sudah ada—misalnya yang disimpan dalam makro atau daftar token lainnya—TeX dapat memeriksa tabel penyimpanan data internalnya untuk menemukan informasi terperinci tentang perintah (atau karakter) yang diwakili token tersebut. Gambar berikut merangkum proses pembuatan token perintah (“pengemasan”) lalu, ketika TeX membutuhkan informasi, membalik prosesnya (“membongkar” token) untuk memperoleh data tentang perintah yang diwakili oleh nilai token tertentu.
### Kode perintah
Bagian dari informasi yang disimpan TeX tentang setiap perintah (primitif atau makro) adalah sesuatu yang disebut *kode perintah*: nilai bilangan bulat yang digunakan mesin TeX (secara internal) untuk mengklasifikasikan perintah—perintah dengan perilaku/fungsi serupa berbagi kode perintah yang sama.
**Catatan**: Untuk sebuah *nonaktif*, karakter individual, kode perintahnya adalah *kode kategori* yang ditetapkan pada saat ia dibaca (di-scan) oleh TeX. Perlu dicatat juga bahwa, kecuali untuk karakter, kode perintah sepenuhnya internal bagi TeX: tidak dapat diakses melalui makro atau perintah primitif—untuk melihat detail itu Anda perlu membaca kode sumber TeX!
Berikut beberapa contoh kode perintah:
* `\hbox`, `\vbox`, `\vtop`, `\vcenter`, `\box` (dan lainnya) semuanya diklasifikasikan sebagai perintah “pembuatan box” dan berbagi kode perintah 20;
* `\def`, `\edef`, `\gdef`, `\xdef` semuanya adalah perintah “definisi makro” dan berbagi kode perintah 97;
* semua makro diklasifikasikan dengan salah satu kode perintah 111, 112, 113, atau 114: perbedaan kode perintah ditentukan oleh penggunaan `\long` atau `\outer` saat mendefinisikan makro:
* 111: kode perintah untuk makro non-long, non-outer (mis., `\def\foo{...}`)
* 112: kode perintah untuk makro long, non-outer (mis., `\long\def\foo{...}`)
* 113: kode perintah untuk makro non-long, outer (mis., `\outer\def\foo{...}`)
* 114: kode perintah untuk makro long, outer (mis., `\long\outer\def\foo{...}`)
TeX juga menggunakan kode perintah untuk mengidentifikasi subset perintah yang diklasifikasikan sebagai “expandable”. Untuk itu, TeX mengaitkan perintah expandable dengan nilai kode perintah yang melebihi nilai ambang 100 (nilai yang digunakan oleh TeX asli Knuth, e-TeX, dan pdfTeX). Akibatnya:
* *tidak dapat diekspansi* perintah (sebagian besar) memiliki kode perintah <= 100
* *expandable* perintah memiliki kode perintah > 100
Oleh karena itu, jika TeX mencari detail untuk perintah tertentu dan mendeteksi kode perintah > 100, TeX langsung tahu bahwa perintah itu expandable. Semua makro dan sejumlah kecil primitif (perintah bawaan) diberi kode perintah yang menunjukkan bahwa mereka expandable: tetapi mengapa TeX repot-repot dengan klasifikasi “expandable” ini? Seperti mungkin Anda duga, itu berarti bahwa perintah-perintah tersebut agak “istimewa”; yaitu, mereka dapat dikenai proses TeX *ekspansi*.
**Catatan (karakter)**: Kecuali jika sebuah karakter telah didefinisikan sebagai aktif (kode kategori 13), semua karakter bersifat non-expandable. Karakter aktif dapat dianggap sebagai “makro mini” satu huruf.
## Ya, ya, tapi apa itu ekspansi???
Kita mencatat bahwa nilai token lebih besar dari 4095 digunakan untuk merepresentasikan perintah; akibatnya, TeX dapat, jika/dan ketika diperlukan, “membongkar” token tersebut untuk mengakses informasi tentang perintah TeX yang diwakili token itu. TeX dapat mencari nilai kode perintahnya untuk menentukan apakah ia termasuk dalam kategori khusus expandable. Tetapi apa yang TeX lakukan dengan informasi itu dan apa arti “bersifat expandable”, yaitu ekspansi, *sebenarnya berarti*?
### Ekspansi: Istilah umum untuk serangkaian operasi
Pada titik tertentu selama pemrosesan TeX, ia perlu mengetahui apakah suatu token mewakili perintah expandable:
* **Tidak**: Jika token perintah itu *tidak* masuk ke kategori expandable, TeX hanya “meneruskannya” ke tahap pemrosesan berikutnya.
* **Ya**: Jika token perintah itu *tidak* masuk ke kategori expandable, Anda dapat menganggap TeX perlu mengambil tindakan yang menghasilkan “penyaringan keluar” token tertentu itu dengan melakukan proses yang disebut TeX sebagai “mengekspansi token tersebut”, atau melakukan ekspansi.
Intinya, ekspansi melibatkan TeX *menghapus* token itu dari inputnya dan *menggantinya* menggantinya dengan token yang muncul dari “proses ekspansi” khusus untuk perintah itu atau kelompok perintah yang berbagi kode perintah yang sama.
Diperlukan latihan dan pengalaman untuk mengetahui kapan TeX sedang, dan tidak sedang, melakukan ekspansi token—halaman 215 The TeXbook mencantumkan situasi ketika token expandable tidak diekspansi. Kenyataannya, proses TeX dalam melakukan ekspansi itu kompleks dan bernuansa.
#### Perintah mana yang expandable?
Jika Anda melihat daftar perintah primitif (bawaan) yang diklasifikasikan mesin TeX sebagai expandable (mis., halaman 212–215 The TeXbook), menjadi jelas bahwa, dalam praktiknya, ekspansi adalah istilah yang cukup umum yang digunakan TeX untuk menggambarkan perilaku sekelompok perintah yang agak eklektik. Hasil dari ekspansi perintah (yang expandable) tertentu memang bervariasi dan kita dapat melihatnya dengan mencantumkan serangkaian perintah expandable—dikelompokkan berdasarkan fungsinya. Semantik tepat dari perintah individual tidak penting di sini; yang paling menarik adalah konsekuensi umum dari tindakan mereka—apa yang sebenarnya *dilakukan atau dicapai*.
| **Perintah** | **Deskripsi** | **Perilaku ekspansi** |
| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| | Urutan token perintah/karakter yang disimpan | Pada dasarnya, ekspansi makro berarti menyisipkan daftar token untuk dibaca TeX. Ini melibatkan:
- membuat daftar token untuk argumen makro apa pun—proses itu mencakup mengidentifikasi/menyerap token pembatas;
- mengambil daftar token yang tersimpan (definisi makro) dan mempersiapkan penyisipan token parameter yang dibuat pada langkah pertama (ke dalam definisi makro).
Secara efektif, ekspansi makro menghapus token makro dari masukan dan menggantinya dengan token yang terkandung dalam definisi.
|
| | Mengubah urutan ekspansi | Penyaringan/pengacakan token |
| | Mencegah ekspansi (ya, mengejutkannya ini diklasifikasikan sebagai perintah expandable) | Menunda ekspansi (semacam penyaringan token) |
| \input, \endinput, \scantokens
| Terkait dengan memasukkan sumber token baru melalui berkas sumber—ya, `\scantokens` termasuk dalam kategori ini karena menggunakan yang disebut “pseudo-file” | Berfungsi sebagai sumber token baru |
| \if, \ifcat, \ifnum, \ifdim, \ifodd, \ifvmode, \ifhmode, \ifmmode, \ifinner, \ifvoid, \ifhbox, \ifvbox, \ifx, \ifeof, \iftrue, \iffalse, \ifcase, \ifdefined, \ifcsname, \iffontchar
| Memulai ekspresi kondisional | Memulai “penyaringan” token: menentukan token berikutnya yang akan diproses. |
| | Mengakhiri ekspresi kondisional | Menghentikan “penyaringan” token: menentukan token mana yang akan diproses |
| | Menyusun/menghasilkan token perintah | Mengubah serangkaian token menjadi satu token perintah |
| \number, \romannumeral, \string, \meaning, \fontname, \jobname, \eTeXrevision
| Mengubah sesuatu menjadi rangkaian token | Menghasilkan beberapa token (yang mewakili kuantitas atau nilai internal) |
| \the, \unexpanded, \detokenize
| `\the` memiliki berbagai kegunaan termasuk penyisipan token; `\detokenize` mengubah daftar token menjadi daftar token karakter; `\unexpanded` mencegah ekspansi token | Menyisipkan/menghasilkan beberapa token atau mengendalikan ekspansi |
| \topmark, \firstmark, \botmark, \splitfirstmark, \splitbotmark, \topmarks, \firstmarks, \botmarks, \splitfirstmarks, \splitbotmarks
| Perintah untuk mengakses daftar token yang memiliki kegunaan khusus | Mengakses sumber token yang disimpan (daftar token) |
Berdasarkan daftar di atas, mungkinkah mengekstrak “perilaku umum” apa pun dari kumpulan perintah ini—untuk memperjelas lagi pemahaman kita tentang ekspansi? Secara perkiraan yang cukup baik, hasil ekspansi sebuah perintah jatuh ke beberapa aktivitas utama:
* pembuatan token
* penyisipan token
* penyaringan token
* mengubah/mengendalikan ekspansi token berikutnya
### Dan akhirnya: apa arti ekspansi?
Kita dapat menganggap bahwa ekspansi token perintah (termasuk karakter aktif) melibatkan TeX **menghapus** token perintah itu dari input dan **menggantinya** menggantikan token itu dengan token lain yang muncul dari perilaku ekspansinya: menghasilkan/menyisipkan token, menyaring token, atau mengubah/mengendalikan ekspansi token berikutnya. Setelah sebuah token diekspansi, TeX akan terus membaca/memproses token apa pun yang mungkin muncul dari proses ekspansi. Tepat kapan atau di mana TeX akan melakukan ekspansi adalah pertanyaan yang sangat berbeda: karena nuansa dan kompleksitas pemrosesan TeX, itu adalah sesuatu yang tidak bisa kita harapkan untuk dibahas sepenuhnya dalam artikel ini, tetapi kita bisa memberikan gambaran umum tentang perilaku pemrosesan input utama TeX.
## Ekspansi dan struktur TeX
Boleh dibilang, cara terbaik untuk melihat bagaimana/di mana TeX membedakan antara perintah expandable dan non-expandable adalah dengan melihat kode sumber TeX.
Secara internal, TeX adalah perangkat lunak yang sangat kompleks; akibatnya, tidak praktis untuk mencoba memberikan deskripsi penuh tentang banyak perilaku bernuansa yang melekat pada operasi TeX. Seperti dicatat, tepat kapan atau di mana TeX sebenarnya melakukan ekspansi saat ia membaca token adalah “agak kompleks”; akibatnya, pembahasan berikut mengasumsikan TeX berada dalam keadaan yang mengharuskan ekspansi terjadi. Situasi ketika TeX akan membaca/membuat token, tetapi tidak melakukan ekspansi, mencakup pembuatan/penyimpanan token untuk `\def` perintah definisi makro atau menyimpan token dalam sebuah `\toks` register.
Diagram berikut memberikan gambaran sederhana tentang bagian inti struktur TeX yang menangani input dan pemrosesan token: tujuannya adalah menyoroti cara token expandable dan non-expandable “disaring” selama pemrosesan input TeX. Bahasa pemrograman C digunakan untuk menjelaskan berbagai fungsi kunci tetapi, semoga, struktur dasarnya akan tetap jelas bahkan jika Anda tidak akrab dengan bahasa C.
### Penjelasan diagram struktur TeX
Secara garis besar, pemrosesan TeX digerakkan oleh sebuah fungsi bernama `maincontrol()` yang, dalam kode sumber TeX, disebut Knuth sebagai “chief executive” dan dijelaskannya sebagai berikut:
> “Sekarang kita sampai pada `maincontrol` rutin, yang memuat sakelar utama yang membuat berbagai bagian TeX melakukan tugasnya, dalam urutan yang tepat… inilah klimaks agung dari program… Kita sekarang berada di pusat jaringan, sistem saraf pusat yang menyentuh sebagian besar bagian lainnya dan mengikat semuanya bersama.”
Deskripsi berikut agak disederhanakan tetapi memberikan “nuansa” struktur dasar perangkat lunak berbasis TeX: bagaimana perintah expandable diidentifikasi (“dicegat”) dan disaring keluar selama pemrosesan input TeX.
Intinya, pada tahap paling awal pemrosesan input TeX, ia menggunakan nilai kode perintah dari perintah (token) saat ini untuk mendeteksi perintah expandable (makro, primitif yang expandable, dan karakter aktif); jika ada yang teridentifikasi, perintah seperti itu “dicegat” dan “dipra-proses”—dengan cara diekspansi. Melalui proses penyaringan (ekspansi) ini, TeX menghapus perintah expandable dari input dan menggantinya dengan token yang muncul dari perilaku ekspansi masing-masing. Setelah proses ekspansi selesai, TeX akan membaca token apa pun yang dihasilkan dari ekspansi itu. Hanya item non-expandable yang diteruskan ke tahap pemrosesan TeX berikutnya: “big switch” tempat TeX mengeksekusi semua perintah primitif non-expandable dan menata karakter.
### Memahami maincontrol()
Fitur `maincontrol()` fungsi ini memuat sebuah pernyataan yang disebut [pernyataan switch](https://en.wikipedia.org/wiki/Switch_statement)—Knuth menyebutnya “big switch”—yang digunakan TeX untuk menjalankan semua *tidak dapat diekspansi* perintah primitif: yang memiliki kode perintah <=100.
Untuk menjalankan perintah tertentu (atau karakter), pernyataan “big switch” ini menggunakan kombinasi mode TeX saat ini:
* mode vertikal internal/luar, atau
* mode horizontal terbatas/paragraf, atau
* mode matematika inline/display
*plus* nilai kode perintah untuk setiap primitif atau karakter—kode perintah dari sebuah *nonaktif* karakter adalah *kode kategori* nilainya. Sebagai catatan, keenam mode TeX dialokasikan nilai bilangan bulat yang dapat digunakan TeX untuk menyimpan dan memulihkan mode saat ini ketika beralih di antara berbagai konstruksi penyusunan huruf—matematika, paragraf, box, dan sebagainya. Berikut bilangan bulat yang dialokasikan untuk berbagai mode TeX:
| | | |
| ------------------------- | ------------------------------------------- | -------------- |
| **Mode** | **Arti** | **Nilai mode** |
| Vertikal luar | Di antara paragraf (membangun halaman) | 1 |
| Vertikal internal | Tepat di dalam sebuah `\vbox{...}` | -1 |
| Horizontal | Saat menyusun/membangun paragraf | 102 |
| Horizontal terbatas | Tepat di dalam sebuah `\hbox{...}` | -102 |
| Matematika display | Penyusunan huruf *tampilan* persamaan/rumus | 203 |
| Matematika inline (rumus) | Penyusunan huruf *sebaris* persamaan/rumus | -203 |
Perhatikan penggunaan nilai negatif untuk komplemen dari berbagai mode, seperti mode vertikal internal vs. luar. Saat memproses perintah dalam `maincontrol()`, TeX menggunakan nilai absolut dari mode saat ini—yaitu, mengabaikan tanda negatif. Jadi, misalnya, jika TeX berada dalam salah satu mode horizontalnya dan perlu memproses karakter dengan kode kategori 11, ia akan menggunakan jumlah $$102 + 11 = 113$$ di dalam “big switch”-nya untuk bercabang ke kode yang memproses karakter tersebut dalam salah satu mode horizontal (membangun paragraf atau di dalam sebuah `\hbox`).
#### Mendapatkan token berikutnya
Fitur `maincontrol()` fungsi memanggil fungsi `getxtoken()` untuk mendapatkan token input berikutnya; kemudian, `getxtoken()` memanggil fungsi input tingkat terendah `getnext()`. Setelah `getnext()` menyelesaikan pekerjaannya, dan menetapkan nilai variabel kunci *variabel global*, `getxtoken()` memeriksa apakah item yang baru saja dibaca mewakili makro atau primitif yang expandable.
Beberapa catatan tentang `getnext()` dan `getxtoken()`:
* **`getnext()`**: ini adalah fungsi input inti TeX. Fungsi ini membaca dan memproses karakter input dari sebuah berkas fisik atau membaca token dari daftar token. Perhatikan bahwa `getnext()` sebenarnya tidak menghitung nilai token, tetapi ia menetapkan sejumlah *global* variabel (mis., kode perintah dan `curcs`) yang digunakan kemudian dalam pemrosesan.
* **`getxtoken()`**: “get expanded token” menggunakan `getnext()` untuk membaca item input berikutnya. Kemudian ia menguji kode perintah dari item yang baru saja dibaca untuk memeriksa apakah item itu mewakili perintah expandable: jika ya, item itu diekspansi atau makro dipanggil. Untuk item non-expandable, `getxtoken()` menghitung nilai token dan detail ini diteruskan ke tahap pemrosesan berikutnya: “big switch” tempat primitif non-expandable dieksekusi dan karakter disusun.
Intinya, melalui `getxtoken()` lah semua item expandable “disaring keluar” sebelum diproses dalam `maincontrol()`: hasilnya “big switch” TeX hanya memproses perintah primitif non-expandable.
Sekali lagi kami tekankan bahwa diagram di atas adalah penyederhanaan karena bagian lain dari pemrosesan TeX juga akan menyebabkan token diekspansi; misalnya:
* ketika TeX mencari (memindai) nilai numerik, ia akan memicu ekspansi dalam pencarian bilangan bulat (dengan memanggil `getxtoken()`) ;
* perintah primitif `\romannumeral` menyebabkan ekspansi—lihat artikel [Ekspansi menggunakan `\romannumeral`](https://www.texdev.net/2011/07/05/expansion-using-romannumeral/) untuk penggunaan fakta tersebut yang bernuansa;
* Fitur `\edef` perintah definisi makro (“expanded definition”) memaksa ekspansi penuh;
* TeX akan mengekspansi token pada titik-titik tertentu saat memproses preamble dari sebuah `\halign` atau `\valign` (kedua perintah ini terkait dengan algoritme penyusunan tabel TeX).
[Bagian 1](/latex/id/artikel-mendalam/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Bagian 2](/latex/id/artikel-mendalam/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Bagian 3](/latex/id/artikel-mendalam/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Bagian 4](/latex/id/artikel-mendalam/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Bagian 5](/latex/id/artikel-mendalam/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Bagian 6](/latex/id/artikel-mendalam/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/id/artikel-mendalam/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.