Module System

BAB 26: Enum

Enum menyatakan 1 nilai sebagai salah satu dari beberapa varian, dan bab ini mengukur varian berdata, match bercabang, serta ukurannya di memori.

1 status pekerjaan hanya bisa bernilai 1 dari 3 kemungkinan: belum dikerjakan, sedang dikerjakan, atau selesai. Kalau 3 keadaan itu disimpan sebagai u8 atau String, tidak ada yang mencegah pengisian dengan nilai di luar daftar, misalnya "selesaii" atau angka 7. Enum memindahkan daftar kemungkinan itu ke dalam tipe, sehingga kompilator bisa menolak nilai yang tidak ada dalam daftar.

Buku resmi Rust menjelaskan enum sebagai cara menyatakan bahwa sebuah nilai adalah 1 dari sekumpulan nilai yang mungkin. Kalimat itu terlihat sederhana, tetapi akibatnya besar: setiap tempat yang menerima enum tahu persis varian apa saja yang mungkin datang, dan match menuntut semua varian itu ditangani.

Setelah bab ini selesai, kamu dapat mendefinisikan enum dengan varian tanpa data maupun varian berdata, menambahkan method padanya, membaca E0599, E0609, dan E0004 sebagai kesalahan seputar varian, serta menjelaskan ukuran enum yang diukur dengan size_of. Semua contoh dijalankan dengan rustc 1.100.0 pada folder /tmp/latihan-rust/bab26.

Satu nilai dengan beberapa bentuk

Enum dideklarasikan dengan kata kunci enum, dan setiap kemungkinan ditulis sebagai varian. Varian paling sederhana tidak membawa data apa pun.

RSRUST
enum Status {
    Menunggu,
    Diproses,
    Selesai,
}

fn main() {
    let status = Status::Diproses;

    match status {
        Status::Menunggu => println!("belum dikerjakan"),
        Status::Diproses => println!("sedang dikerjakan"),
        Status::Selesai => println!("sudah selesai"),
    }
}
CodeTEXT
sedang dikerjakan

Nilai enum dibuat dengan menulis nama tipe lalu :: lalu nama varian, misalnya Status::Diproses. Bentuk itu mirip associated function, dan Reference Rust menyebut varian sebagai konstruktor yang bisa dipakai untuk membuat maupun mencocokkan nilai. Karena itu Status::Diproses adalah nilai utuh, bukan label yang harus digabung dengan angka lain.

match memeriksa nilai itu lalu menjalankan 1 cabang saja. Setiap cabang menulis pola varian di kiri => dan kode yang dijalankan di kanan. Kalau semua varian ditangani, hasil match bisa dipakai sebagai nilai, misalnya let teks = match status { ... };.

Alternatif enum untuk 3 keadaan di atas adalah bool atau String. bool hanya punya 2 nilai, sehingga keadaan ketiga harus ditambahkan sebagai variabel lain yang bisa saja lupa diperbarui. String bisa menampung nilai apa pun, termasuk salah ketik, dan pemeriksaannya baru terjadi saat program berjalan. Enum menutup kedua celah itu dengan mendaftarkan nilai yang sah pada tingkat tipe, dan biayanya hanya 1 byte pada contoh yang diukur nanti.

Varian yang membawa data

Varian boleh membawa data, dan tiap varian boleh membawa tipe yang berbeda. Enum Bentuk berikut menyimpan sisi untuk persegi dan jari jari untuk lingkaran dalam 1 tipe.

RSRUST
enum Bentuk {
    Persegi(f64),
    Lingkaran(f64),
}

impl Bentuk {
    fn luas(&self) -> f64 {
        match self {
            Bentuk::Persegi(sisi) => sisi * sisi,
            Bentuk::Lingkaran(jari) => 3.14159 * jari * jari,
        }
    }
}

fn main() {
    let kotak = Bentuk::Persegi(3.0);
    let bola = Bentuk::Lingkaran(2.0);

    println!("persegi: {:.2}", kotak.luas());
    println!("lingkaran: {:.4}", bola.luas());
}
CodeTEXT
persegi: 9.00
lingkaran: 12.5664

Varian berdata ditulis seperti pemanggilan fungsi, yaitu Bentuk::Persegi(3.0). Pada match self, pola Bentuk::Persegi(sisi) mengikat isi varian ke variabel sisi, sehingga rumus luas bisa memakainya. Perhatikan bahwa tidak ada field sisi pada tipe Bentuk; yang ada adalah nilai f64 di dalam varian, dan pola itulah cara mengambilnya.

1 nilai Bentuk diperiksa match self, lalu bercabang ke varian Persegi yang menghitung sisi kali sisi dan varian Lingkaran yang menghitung 3.14159 kali jari kali jari

Alur 1 nilai enum: match memilih varian, lalu tiap cabang memakai data yang dibawa varian itu.

Gambar di atas menunjukkan hal yang tidak terlihat dari teks kode: percabangan terjadi pada nilai yang sama. Kedua cabang tidak mungkin berjalan bersamaan, karena 1 nilai Bentuk hanya berisi 1 varian pada satu waktu.

Struct variant

Selain data posisional, varian bisa membawa field bernama. Bentuk ini dipakai kalau datanya lebih dari 1 dan namanya perlu terlihat di tempat pembuatan.

RSRUST
enum Pesan {
    Teks(String),
    Titik { x: i32, y: i32 },
}

fn main() {
    let a = Pesan::Teks(String::from("halo"));
    let b = Pesan::Titik { x: 3, y: 4 };

    match a {
        Pesan::Teks(isi) => println!("teks: {}", isi),
        Pesan::Titik { .. } => println!("titik"),
    }

    match b {
        Pesan::Titik { x, y } => println!("titik: {} {}", x, y),
        Pesan::Teks(_) => println!("teks"),
    }
}
CodeTEXT
teks: halo
titik: 3 4

Pola Pesan::Titik { x, y } membongkar field berdasarkan nama, dan urutan penulisannya tidak harus sama dengan urutan di deklarasi. Tanda .. pada cabang pertama berarti field sisanya diabaikan, sedangkan _ pada cabang kedua berarti seluruh isi varian diabaikan. Keduanya berguna saat hanya sebagian data yang dibutuhkan.

Pengikatan pada pola juga mengikuti aturan pemindahan yang sama seperti variabel biasa. Pola Pesan::Teks(isi) memindahkan String keluar dari varian, sehingga nilai a tidak bisa dipakai lagi sesudah match. Kalau isinya hanya perlu dibaca, pola ditulis pada referensi, misalnya match &a dengan pola yang sama, dan isi menjadi &String.

Method pada enum

Enum adalah tipe, sehingga blok impl berlaku sama seperti pada struct. Method bisa membaca varian lewat match self, dan hasilnya dipakai pemanggil tanpa perlu tahu varian mana yang sedang dipegang.

RSRUST
enum Status {
    Menunggu,
    Diproses,
    Selesai,
}

impl Status {
    fn selesai(&self) -> bool {
        match self {
            Status::Selesai => true,
            _ => false,
        }
    }
}

fn main() {
    let daftar = vec![Status::Menunggu, Status::Selesai, Status::Diproses];
    let jumlah = daftar.iter().filter(|s| s.selesai()).count();

    println!("total: {} selesai: {}", daftar.len(), jumlah);
}
CodeTEXT
total: 3 selesai: 1

Method selesai memakai &self karena hanya membaca varian. Tanda _ menangani 2 varian lain sekaligus, dan itu sah selama perilakunya memang sama. Kalau nanti ada varian baru yang butuh perlakuan berbeda, _ akan menutupinya tanpa peringatan, sehingga pola yang menyebut semua varian secara eksplisit lebih aman untuk enum yang kemungkinan bertambah.

Varian yang tidak ada: E0599

Nama varian diperiksa saat kompilasi. Menulis varian yang tidak ada di deklarasi ditolak, walaupun namanya mirip.

RSRUST
enum Status {
    Menunggu,
    Selesai,
}

fn main() {
    let status = Status::Batal;
    match status {
        Status::Menunggu => println!("tunggu"),
        Status::Selesai => println!("selesai"),
    }
}
CodeTEXT
error[E0599]: no variant, associated function, or constant named `Batal` found for enum `Status` in the current scope
 --> uji/salah_varian.rs:7:26
  |
1 | enum Status {
  | ----------- variant, associated function, or constant `Batal` not found for this enum
...
7 |     let status = Status::Batal;
  |                          ^^^^^ variant, associated function, or constant not found in `Status`

error: aborting due to 1 previous error

For more information about this error, try `rustc --explain E0599`.

Pesan itu menyebut 3 kemungkinan sekaligus, yaitu varian, associated function, dan konstanta, karena ketiganya memang diakses lewat :: pada tipe. Kode E0599 sama dengan yang muncul saat nama method salah, hanya saja kalimatnya menyebut enum dan varian. Perbaikannya menambah varian Batal di deklarasi, atau memakai varian yang sudah ada.

Field langsung pada enum: E0609

Data di dalam varian tidak bisa dibaca seperti field struct. Program berikut mencoba mengakses x pada nilai yang bertipe Bentuk.

RSRUST
enum Bentuk {
    Persegi(f64),
    Lingkaran(f64),
}

fn main() {
    let kotak = Bentuk::Persegi(3.0);
    println!("{}", kotak.x);
}
CodeTEXT
error[E0609]: no field `x` on type `Bentuk`
 --> uji/salah_field.rs:8:26
  |
8 |     println!("{}", kotak.x);
  |                          ^ unknown field

error: aborting due to 1 previous error

Tipe Bentuk tidak punya field sama sekali, karena datanya berada di dalam varian. Akses langsung hanya mungkin kalau variannya sudah dipastikan lewat match, if let, atau method yang melakukan pembongkaran. Kesalahan ini juga muncul pada struct yang salah nama tipe, sehingga pesan unknown field perlu dibaca bersama nama tipe yang disebut di baris pertama.

match yang belum lengkap: E0004

match wajib menangani semua varian. Kalau 1 varian terlewat, kompilator menolak dan menyebut varian yang belum tertangani.

RSRUST
enum Status {
    Menunggu,
    Diproses,
    Selesai,
}

fn main() {
    let status = Status::Menunggu;

    match status {
        Status::Menunggu => println!("tunggu"),
        Status::Selesai => println!("selesai"),
    }
}
CodeTEXT
error[E0004]: non-exhaustive patterns: `Status::Diproses` not covered
  --> uji/salah_match.rs:10:11
   |
10 |     match status {
   |           ^^^^^^ pattern `Status::Diproses` not covered
   |
note: `Status` defined here
  --> uji/salah_match.rs:1:6
   |
 1 | enum Status {
   |      ^^^^^^
 2 |     Menunggu,
 3 |     Diproses,
   |     -------- not covered
   = note: the matched value is of type `Status`
help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
   |
12 ~         Status::Selesai => println!("selesai"),
13 ~         Status::Diproses => todo!(),
   |

error: aborting due to 1 previous error

For more information about this error, try `rustc --explain E0004`.

Pemeriksaan ini yang membuat enum berguna saat varian bertambah. Kalau Status::Batal ditambahkan ke deklarasi, setiap match yang tidak memakai _ akan gagal dikompilasi sampai cabangnya ditulis. Kompilator juga menandai baris deklarasi varian yang terlewat, sehingga penyebabnya terlihat tanpa membaca ulang seluruh program.

Ukuran enum di memori

Karena hanya 1 varian yang aktif, ukuran enum tidak sama dengan jumlah ukuran semua varian. Program berikut mengukur beberapa enum dengan size_of.

RSRUST
use std::mem::size_of;

enum Kecil {
    A,
    B,
    C,
}

enum Angka {
    Bulat(i32),
    Pecahan(f64),
}

enum Teks {
    Kosong,
    Isi(String),
}

fn main() {
    println!("Kecil: {}", size_of::<Kecil>());
    println!("Angka: {}", size_of::<Angka>());
    println!("Teks: {}", size_of::<Teks>());
    println!("String: {}", size_of::<String>());
    println!("f64: {}", size_of::<f64>());
}
CodeTEXT
Kecil: 1
Angka: 16
Teks: 24
String: 24
f64: 8

Kecil hanya butuh 1 byte karena 3 varian cukup ditandai dengan 1 angka kecil. Angka berukuran 16 byte, yaitu 8 byte untuk data terbesar dan 8 byte untuk penanda varian beserta padding, sehingga lebih besar daripada f64 yang hanya 8 byte. Teks berukuran 24 byte, sama dengan String, dan hasil ukur itu menunjukkan penanda varian tidak selalu menambah ukuran.

Angka tersebut adalah hasil ukur pada versi kompilator ini, bukan jaminan bahasa. Reference Rust menyatakan bahwa layout tipe bisa berubah pada setiap kompilasi, dan untuk enum cara penanda varian ditata juga termasuk bagian dari layout. Kalau ukuran dan susunan harus pasti, misalnya karena data dibaca program lain, penanda #[repr(C)] dipakai dan konsekuensinya dibahas di bab tentang repr.

Enum unit-only dan cast angka

Enum yang semua variannya tanpa data bisa diberi nilai angka, dan nilainya dibaca lewat cast.

RSRUST
#[derive(Debug)]
enum Kode {
    Terima = 200,
    Redirect = 301,
    Error = 404,
}

fn main() {
    println!("{:?} {}", Kode::Terima, Kode::Terima as u16);
    println!("{:?} {}", Kode::Redirect, Kode::Redirect as u16);
    println!("{:?} {}", Kode::Error, Kode::Error as u16);
}
CodeTEXT
Terima 200
Redirect 301
Error 404

Cast hanya berlaku untuk enum unit-only, yaitu enum yang semua variannya tanpa field. Reference Rust menuliskan syaratnya: "If an enumeration is unit-only (with no tuple and struct variants), then its discriminant can be directly accessed with a numeric cast". Enum seperti Bentuk yang membawa f64 tidak bisa di-cast, karena tidak ada 1 angka yang mewakili seluruh isi varian.

Nilai eksplisit juga berguna saat enum dipakai sebagai kode yang dibaca sistem lain, misalnya kode status HTTP. Tanpa nilai eksplisit, angka yang dipakai mengikuti urutan deklarasi, dan urutan itu bisa berubah saat varian baru disisipkan di tengah. Menulis angkanya sendiri membuat nilai tidak bergeser karena penambahan varian.

Latihan

  1. Buat enum Suhu { Celsius(f64), Fahrenheit(f64) } dengan method ke_celsius(&self) -> f64 yang mengubah kedua varian ke satuan yang sama.
  2. Tambahkan varian Kelvin(f64) pada enum itu, lalu jalankan rustc dan kutip pesan E0004 yang muncul sebelum cabangnya ditulis.
  3. Buat enum Arah { Utara, Timur, Selatan, Barat } dan method putar_kanan(&self) -> Arah yang mengembalikan arah berikutnya searah jarum jam.
  4. Ukur size_of untuk enum dengan 2 varian u8 dan untuk enum dengan 2 varian u64, lalu bandingkan dengan ukuran tipe datanya.

Ringkasan

Enum menyatakan bahwa 1 nilai adalah salah satu dari beberapa varian, dan varian boleh membawa data posisional maupun field bernama. Varian diakses lewat ::, dan match dipakai untuk memilih cabang sekaligus membongkar datanya, dengan kewajiban menangani semua varian atau E0004 akan muncul. Nama varian yang salah ditolak sebagai E0599, sedangkan akses field langsung pada enum ditolak sebagai E0609. Ukuran enum mengikuti varian terbesar ditambah penanda, dan hasil ukur di bab ini menunjukkan 1 byte untuk 3 varian tanpa data, 16 byte untuk varian f64, serta 24 byte untuk varian String.

Referensi

  1. The Rust Programming Language. Defining an Enum.
  2. The Rust Reference. Enumerations.
  3. The Rust Reference. Type layout.