Makro Deklaratif (`macro_rules!`)

Makro adalah cara menulis kode yang menulis kode! Makro mirip dengan fungsi, tetapi bekerja pada pohon sintaksis (struktur kode Anda), bukan pada nilai.

• Makro membantu mengabstraksikan kode yang berulang.
• Makro memungkinkan penggunaan Bahasa Spesifik Domain (DSL) di dalam Rust.
• Makro dijalankan saat kompilasi dan diperluas menjadi kode Rust biasa sebelum kompilasi.

Makro deklaratif Rust menggunakan kata kunci macro_rules!. Makro ini mendefinisikan sekumpulan aturan yang mencocokkan pola tertentu dari kode Rust.

Anggaplah ini sebagai pencocokan pola untuk cuplikan kode. Saat kompilator melihat pemanggilan makro, kompilator mencoba mencocokkan input dengan salah satu aturan yang telah Anda definisikan.

Mari kita buat makro yang sangat sederhana untuk mencetak sapaan. Perhatikan kata kunci macro_rules! dan sintaks () => {} yang mendefinisikan aturan tanpa pola input.

Coba jalankan contoh ini:

Makro dapat menerima input menggunakan "penentu". Penentu ini memberi tahu makro jenis sintaks Rust yang harus diharapkan untuk ditangkap.

• $expr: Sebuah ekspresi (misalnya, 1 + 2, "hello")
• $ident: Sebuah pengenal (misalnya, nama variabel atau nama fungsi)
• $ty: Sebuah tipe (misalnya, i32, String)
• $block: Sebuah blok kode (misalnya, { ... })
• ...dan masih banyak lagi!

Berikut makro yang menerima sebuah ekspresi ($e:expr) dan mencetak nilainya. :expr adalah penentunya.

$e yang ditangkap kemudian tersedia untuk digunakan dalam isi makro. Makro stringify! mengubah ekspresi menjadi representasi stringnya.

Bagaimana jika Anda ingin makro menerima beberapa argumen dengan tipe yang sama? Anda dapat menggunakan operator pengulangan: $()*.

• $(): Konten di dalamnya adalah pola yang akan diulang.
• *: Nol atau lebih pengulangan.
• +: Satu atau lebih pengulangan.
• Anda juga dapat menentukan pemisah, seperti $(...),* untuk item yang dipisahkan koma.

Mari kita buat makro yang menerima beberapa ekspresi, dipisahkan dengan koma, lalu mencetak masing-masing ekspresi secara terpisah. Ini berguna untuk membuat struktur yang menyerupai daftar.

Makro Rust bersifat "higienis". Artinya, variable yang didefinisikan di dalam makro tidak akan secara tidak sengaja bertabrakan dengan variable di luar makro, meskipun namanya sama.

Kompilator mengganti nama berbagai hal secara internal selama ekspansi untuk mencegah efek samping yang tidak diinginkan, sehingga makro lebih aman dan lebih mudah diprediksi saat digunakan.

Terkadang makro tidak melakukan ekspansi seperti yang Anda harapkan. Rust menyediakan cara untuk melihat kode hasil ekspansi:

• Jalankan cargo expand (memerlukan pemasangan alat cargo-expand)
• Gunakan rustc --pretty expanded secara langsung pada file sumber Anda.

Ini menampilkan kode Rust mentah yang dihasilkan makro Anda, sehingga sangat membantu untuk men-debug dan memahami perilaku makro yang kompleks!

Perhatikan definisi makro berikut:

macro_rules! make_tuple {
    ( $x:expr, $y:expr ) => {
        ($x, $y)
    };
}

Manakah dari baris berikut yang akan berhasil dikompilasi dan menggunakan makro make_tuple!?

Dalam pelajaran ini, Anda telah mempelajari makro deklaratif menggunakan macro_rules!:

• Makro menghasilkan kode saat kompilasi, sehingga mengabstraksikan pola yang berulang.
• Makro menggunakan pencocokan pola untuk menangkap input berdasarkan sintaks.
• Penentu seperti $expr dan $ident menentukan jenis sintaks yang diharapkan.
• Operator pengulangan seperti $()* menangani beberapa argumen dengan pemisah yang fleksibel.
• Makro bersifat higienis, sehingga mencegah konflik nama yang tidak disengaja.

Makro adalah alat yang sangat berguna untuk mengurangi kode berulang dan membuat API Rust yang fleksibel serta ergonomis!