Makro Praktis
Kasus penggunaan.
Makro Praktis adalah pelajaran Scala for Backend Engineering & Functional Programming gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Scala for Backend Engineering & Functional Programming, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Scala for Backend Engineering & Functional Programming mencakup 4 pelajaran total.
Makro di Dunia Nyata
Di luar contoh sederhana, makro menyelesaikan masalah nyata: menangkap konteks sumber, menurunkan kelas tipe, memvalidasi literal, dan menghasilkan kode tanpa kode boilerplate.
Kasus Penggunaan: assert dengan Pesan
Sebuah makro dapat menangkap teks sumber dari kondisi yang gagal untuk secara otomatis menghasilkan pesan assertion yang informatif.
import scala.quoted.*
inline def myAssert(inline cond: Boolean): Unit =
${ assertImpl('cond) }Menangkap Kode Sumber
Di dalam makro, cond.show (melalui API refleksi) menghasilkan kode sumber literal dari ekspresi, yang kemudian Anda sisipkan ke dalam pesan kesalahan.
import scala.quoted.*
def assertImpl(cond: Expr[Boolean])(using q: Quotes): Expr[Unit] = {
import q.reflect.*
val src = Expr(cond.asTerm.show)
'{ if (!${ cond }) throw new AssertionError("failed: " + ${ src }) }
}Kasus Penggunaan: Validasi Waktu Kompilasi
Validasikan literal (seperti regex atau nomor port) pada waktu kompilasi agar nilai yang tidak valid tidak pernah mencapai runtime.
import scala.quoted.*
inline def port(inline n: Int): Int = ${ portImpl('n) }Menghentikan Eksekusi untuk Input yang Tidak Valid
Ekstrak literal, periksa nilainya, lalu panggil report.errorAndAbort untuk nilai yang tidak valid—mengubah bug runtime menjadi kesalahan kompilasi.
import scala.quoted.*
def portImpl(n: Expr[Int])(using q: Quotes): Expr[Int] = {
import q.reflect.*
val v = n.valueOrAbort
if (v < 1 || v > 65535) report.errorAndAbort("invalid port")
n
}Kasus Penggunaan: Derivasi Kelas Tipe
Makro (sering kali melalui inline + scala.deriving.Mirror) dapat menghasilkan instans kelas tipe seperti penyandi JSON untuk setiap kelas kasus tanpa kode boilerplate.
import scala.deriving.Mirror
trait Show[T] { def show(t: T): String }
inline def derived[T](using Mirror.Of[T]): Show[T] = ???Menggunakan Mirror
Sebuah Mirror menyediakan tipe dan label bidang suatu produk pada waktu kompilasi. Jika digabungkan dengan inline, Anda dapat mengiterasi bidang-bidang tersebut untuk membangun sebuah instans.
import scala.deriving.*
import scala.compiletime.*
inline def labels[T](using m: Mirror.ProductOf[T]): List[String] =
constValueTuple[m.MirroredElemLabels].toList.map(_.toString)Kasus Penggunaan: Pencatatan dengan Posisi
Sebuah makro dapat membaca Position dari API refleksi untuk menambahkan berkas dan nomor baris ke pesan pencatatan tanpa biaya runtime.
import scala.quoted.*
def posImpl(using q: Quotes): Expr[String] = {
import q.reflect.*
val p = Position.ofMacroExpansion
Expr(s"${p.sourceFile.name}:${p.startLine + 1}")
}Kapan TIDAK Menggunakan Makro
Makro memang kuat, tetapi mahal untuk dipelihara dan di-debug. Utamakan fungsi biasa, metode inline, atau derivasi given. Gunakan makro hanya jika kebutuhan tersebut tidak dapat diungkapkan dengan cara-cara itu.
Menguji Makro
Uji perilaku yang dihasilkan seperti kode biasa, dan uji bahwa input yang tidak valid gagal dikompilasi menggunakan alat seperti typeCheckErrors dari utilitas pengujian waktu kompilasi.
Padanan Saat Runtime
Sebuah makro validasi waktu kompilasi menghasilkan efek yang sama seperti pemeriksaan runtime mandiri ini—tetapi kegagalannya terjadi selama kompilasi, bukan saat runtime.
object Main {
def port(n: Int): Int = {
require(n >= 1 && n <= 65535, "invalid port")
n
}
def main(args: Array[String]): Unit = {
println(port(8080)) // 8080
}
}Pemeriksaan Singkat
Apa keuntungan utama memvalidasi literal dengan makro dibandingkan saat runtime?
Ringkasan
Anda telah menjelajahi kasus penggunaan makro praktis:
assertyang menangkap sumber- validasi waktu kompilasi dengan
errorAndAbort - derivasi kelas tipe melalui
Mirror - pencatatan yang menyertakan posisi
- kapan harus menghindari makro dan cara mengujinya
Anda telah menyelesaikan kursus Metaprogramming dan Makro.
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Makro Praktis” gratis?
Ya — teks lengkap “Makro Praktis” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Scala for Backend Engineering & Functional Programming, upgrade ke CoddyKit PRO. Kursus Scala for Backend Engineering & Functional Programming mencakup 4 pelajaran total.
Apa yang akan aku pelajari di “Makro Praktis”?
Kasus penggunaan. Kamu berlatih Scala for Backend Engineering & Functional Programming dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.
Apakah aku perlu pengalaman untuk memulai Scala for Backend Engineering & Functional Programming?
Tidak diperlukan pengalaman sebelumnya. Scala for Backend Engineering & Functional Programming di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.
Berapa lama pelajaran “Makro Praktis” memakan waktu?
Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.
Bisakah aku menulis dan menjalankan kode dalam pelajaran Scala for Backend Engineering & Functional Programming ini?
Ya. Setiap pelajaran Scala for Backend Engineering & Functional Programming menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.
Semua pelajaran dalam kursus ini
- Method Inline
- Dasar-Dasar Makro
- Quote dan Splice
- Makro Praktis