Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Mendefinisikan Enum

Jika struct memberimu cara untuk mengelompokkan field dan data yang saling berkaitan, seperti Rectangle dengan width dan height-nya, enum memberimu cara untuk menyatakan bahwa sebuah nilai adalah salah satu dari sekumpulan nilai yang mungkin. Sebagai contoh, kita mungkin ingin menyatakan bahwa Rectangle adalah salah satu dari bentuk-bentuk yang mungkin, yang juga mencakup Circle dan Triangle. Untuk melakukan itu, Rust mengizinkan kita mengodekan kemungkinan-kemungkinan tersebut sebagai sebuah enum.

Mari kita lihat situasi yang ingin kita ekspresikan dalam kode untuk melihat mengapa enum berguna dan lebih tepat dibanding struct dalam kasus ini. Katakan kita harus bekerja dengan alamat IP. Saat ini, ada dua standar utama yang digunakan untuk alamat IP: versi empat dan versi enam. Karena hanya itulah kemungkinan alamat IP yang akan ditemui program kita, kita bisa mengenumerasi semua varian yang mungkin — di situlah istilah enumeration berasal.

Alamat IP mana pun bisa berupa alamat versi empat atau versi enam, tetapi tidak keduanya sekaligus. Sifat alamat IP inilah yang membuat struktur data enum tepat digunakan, karena nilai enum hanya bisa berupa salah satu variannya. Alamat versi empat dan versi enam tetap pada dasarnya merupakan alamat IP, jadi keduanya harus diperlakukan sebagai tipe yang sama ketika kode menangani situasi yang berlaku untuk segala jenis alamat IP.

Kita bisa mengekspresikan konsep ini dalam kode dengan mendefinisikan sebuah enumerasi IpAddrKind dan menyebutkan jenis IP address yang mungkin, yaitu V4 dan V6. Inilah varian dari enum tersebut:

enum IpAddrKind {
    V4,
    V6,
}

fn main() {
    let four = IpAddrKind::V4;
    let six = IpAddrKind::V6;

    route(IpAddrKind::V4);
    route(IpAddrKind::V6);
}

fn route(ip_kind: IpAddrKind) {}

IpAddrKind kini menjadi tipe data kustom yang bisa kita gunakan di bagian kode lainnya.

Nilai Enum

Kita bisa membuat instance dari masing-masing dua varian IpAddrKind seperti ini:

enum IpAddrKind {
    V4,
    V6,
}

fn main() {
    let four = IpAddrKind::V4;
    let six = IpAddrKind::V6;

    route(IpAddrKind::V4);
    route(IpAddrKind::V6);
}

fn route(ip_kind: IpAddrKind) {}

Perhatikan bahwa varian enum berada dalam namespace yang ditentukan oleh identifikasinya, dan kita menggunakan dua titik dua untuk memisahkan keduanya. Ini berguna karena kini kedua nilai IpAddrKind::V4 dan IpAddrKind::V6 memiliki tipe yang sama: IpAddrKind. Dengan begitu, misalnya, kita bisa mendefinisikan sebuah fungsi yang menerima IpAddrKind apa pun:

enum IpAddrKind {
    V4,
    V6,
}

fn main() {
    let four = IpAddrKind::V4;
    let six = IpAddrKind::V6;

    route(IpAddrKind::V4);
    route(IpAddrKind::V6);
}

fn route(ip_kind: IpAddrKind) {}

Dan kita bisa memanggil fungsi ini dengan varian mana pun:

enum IpAddrKind {
    V4,
    V6,
}

fn main() {
    let four = IpAddrKind::V4;
    let six = IpAddrKind::V6;

    route(IpAddrKind::V4);
    route(IpAddrKind::V6);
}

fn route(ip_kind: IpAddrKind) {}

Menggunakan enum punya lebih banyak lagi keuntungannya. Jika kita pikirkan lagi tipe alamat IP kita, saat ini kita belum punya cara untuk menyimpan data alamat IP yang sebenarnya; kita hanya tahu jenis-nya. Mengingat kamu baru saja mempelajari struct di Bab 5, kamu mungkin tergoda untuk menyelesaikan masalah ini dengan struct seperti yang ditampilkan di Listing 6-1.

fn main() {
    enum IpAddrKind {
        V4,
        V6,
    }

    struct IpAddr {
        kind: IpAddrKind,
        address: String,
    }

    let home = IpAddr {
        kind: IpAddrKind::V4,
        address: String::from("127.0.0.1"),
    };

    let loopback = IpAddr {
        kind: IpAddrKind::V6,
        address: String::from("::1"),
    };
}
Listing 6-1: Menyimpan data dan varian IpAddrKind dari sebuah alamat IP menggunakan struct

Di sini, kita telah mendefinisikan struct IpAddr yang punya dua field: field kind bertipe IpAddrKind (enum yang kita definisikan sebelumnya) dan field address bertipe String. Kita punya dua instance struct ini. Yang pertama adalah home, dengan nilai IpAddrKind::V4 sebagai kind-nya beserta data alamat 127.0.0.1 yang terkait. Instance kedua adalah loopback. Instance ini memiliki varian IpAddrKind lainnya sebagai nilai kind-nya, yaitu V6, beserta alamat ::1 yang terkait dengannya. Kita telah menggunakan struct untuk mengikat nilai kind dan address bersama, sehingga kini varian tersebut terkait dengan nilainya.

Namun, mewakili konsep yang sama hanya dengan enum jauh lebih ringkas: Alih-alih menaruh enum di dalam struct, kita bisa langsung menaruh data ke dalam setiap varian enum. Definisi baru dari enum IpAddr ini menyatakan bahwa kedua varian V4 dan V6 akan memiliki nilai String yang terkait:

fn main() {
    enum IpAddr {
        V4(String),
        V6(String),
    }

    let home = IpAddr::V4(String::from("127.0.0.1"));

    let loopback = IpAddr::V6(String::from("::1"));
}

Kita melampirkan data ke setiap varian enum secara langsung, sehingga tidak perlu struct tambahan. Di sini, kita juga lebih mudah melihat detail lain tentang cara kerja enum: Nama setiap varian enum yang kita definisikan juga menjadi sebuah fungsi yang membuat instance dari enum tersebut. Artinya, IpAddr::V4() adalah pemanggilan fungsi yang menerima argumen String dan mengembalikan sebuah instance tipe IpAddr. Kita otomatis mendapatkan fungsi konstruktor ini sebagai hasil dari pendefinisian enum tersebut.

Ada keuntungan lain menggunakan enum alih-alih struct: Setiap varian bisa memiliki tipe dan jumlah data terkait yang berbeda. Alamat IP versi empat akan selalu punya empat komponen numerik dengan nilai antara 0 dan 255. Jika kita ingin menyimpan alamat V4 sebagai empat nilai u8 tetapi tetap mengekspresikan alamat V6 sebagai satu nilai String, hal itu tidak bisa kita lakukan dengan struct. Enum menangani kasus ini dengan mudah:

fn main() {
    enum IpAddr {
        V4(u8, u8, u8, u8),
        V6(String),
    }

    let home = IpAddr::V4(127, 0, 0, 1);

    let loopback = IpAddr::V6(String::from("::1"));
}

Kita telah menunjukkan beberapa cara berbeda untuk mendefinisikan struktur data yang menyimpan alamat IP versi empat dan versi enam. Namun, ternyata keinginan untuk menyimpan alamat IP dan mengodekan jenisnya begitu umum sehingga standard library punya definisi yang bisa kita gunakan! Mari kita lihat bagaimana standard library mendefinisikan IpAddr. Library tersebut punya enum dan varian yang persis sama dengan yang kita definisikan dan gunakan, tetapi ia menanamkan data alamat di dalam varian-varian tersebut dalam bentuk dua struct berbeda, yang definisinya berbeda untuk tiap varian:

#![allow(unused)]
fn main() {
struct Ipv4Addr {
    // --snip--
}

struct Ipv6Addr {
    // --snip--
}

enum IpAddr {
    V4(Ipv4Addr),
    V6(Ipv6Addr),
}
}

Kode ini menggambarkan bahwa kamu bisa menaruh data apa pun di dalam varian enum: string, tipe numerik, atau struct, sebagai contoh. Kamu bahkan bisa menyertakan enum lain! Selain itu, tipe dari standard library sering kali tidak jauh lebih rumit dari apa yang bisa kamu pikirkan sendiri.

Perhatikan bahwa meskipun standard library sudah berisi definisi untuk IpAddr, kita tetap bisa membuat dan menggunakan definisi kita sendiri tanpa konflik karena kita belum membawa definisi dari standard library tersebut ke dalam scope kita. Kita akan membahas lebih lanjut tentang membawa tipe ke dalam scope di Bab 7.

Mari kita lihat contoh lain dari sebuah enum di Listing 6-2: enum ini punya beragam tipe yang tertanam di dalam variannya.

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

fn main() {}
Listing 6-2: Enum Message yang variannya menyimpan nilai dengan tipe dan jumlah berbeda

Enum ini punya empat varian dengan tipe berbeda:

  • Quit: Tidak punya data sama sekali
  • Move: Memiliki field bernama, seperti struct
  • Write: Memuat satu buah String
  • ChangeColor: Memuat tiga nilai i32

Mendefinisikan enum dengan varian seperti pada Listing 6-2 mirip dengan mendefinisikan beberapa definisi struct yang berbeda, kecuali enum tidak menggunakan keyword struct dan semua varian dikelompokkan bersama di dalam tipe Message. Struct berikut bisa menyimpan data yang sama dengan yang disimpan oleh varian enum sebelumnya:

struct QuitMessage; // unit struct
struct MoveMessage {
    x: i32,
    y: i32,
}
struct WriteMessage(String); // tuple struct
struct ChangeColorMessage(i32, i32, i32); // tuple struct

fn main() {}

Tetapi jika kita menggunakan struct yang berbeda-beda, yang masing-masing memiliki tipe sendiri, kita tidak bisa semudah itu mendefinisikan fungsi yang menerima segala jenis pesan seperti yang bisa kita lakukan dengan enum Message pada Listing 6-2, yang merupakan satu tipe tunggal.

Masih ada satu kemiripan lain antara enum dan struct: Sama seperti kita bisa mendefinisikan method pada struct menggunakan impl, kita juga bisa mendefinisikan method pada enum. Berikut method bernama call yang bisa kita definisikan pada enum Message kita:

fn main() {
    enum Message {
        Quit,
        Move { x: i32, y: i32 },
        Write(String),
        ChangeColor(i32, i32, i32),
    }

    impl Message {
        fn call(&self) {
            // method body would be defined here
        }
    }

    let m = Message::Write(String::from("hello"));
    m.call();
}

Badan method akan menggunakan self untuk mendapatkan nilai yang kita panggil method-nya. Dalam contoh ini, kita telah membuat variabel m dengan nilai Message::Write(String::from("hello")), dan itulah yang akan menjadi self di dalam badan method call ketika m.call() berjalan.

Mari kita lihat enum lain di standard library yang sangat umum dan berguna: Option.

Enum Option

Bagian ini membahas studi kasus tentang Option, sebuah enum lain yang didefinisikan oleh standard library. Tipe Option mengodekan skenario yang sangat umum, di mana sebuah nilai mungkin berisi sesuatu, atau mungkin kosong.

Sebagai contoh, jika kamu meminta item pertama pada list yang tidak kosong, kamu akan mendapatkan sebuah nilai. Jika kamu meminta item pertama pada list yang kosong, kamu tidak akan mendapatkan apa pun. Mengekspresikan konsep ini dalam sistem tipe berarti compiler bisa memeriksa apakah kamu sudah menangani semua kasus yang seharusnya kamu tangani; kemampuan ini bisa mencegah bug yang sangat umum terjadi di bahasa pemrograman lain.

Desain bahasa pemrograman sering dipikirkan dari sudut fitur apa saja yang kamu sertakan, tetapi fitur yang kamu kecualikan pun penting. Rust tidak punya fitur null yang dimiliki banyak bahasa lain. Null adalah nilai yang berarti tidak ada nilai di sana. Dalam bahasa yang punya null, variabel selalu bisa berada dalam salah satu dari dua keadaan: null atau bukan-null.

Dalam presentasinya tahun 2009 berjudul “Null References: The Billion Dollar Mistake,” Tony Hoare, penemu null, berkata begini:

Saya menyebutnya kesalahan sen dolar miliar saya. Saat itu, saya sedang merancang sistem tipe komprehensif pertama untuk reference dalam sebuah bahasa berorientasi objek. Tujuan saya adalah memastikan penggunaan reference apa pun harus benar-benar aman, dengan pemeriksaan yang dilakukan otomatis oleh compiler. Tetapi saya tidak bisa menahan godaan untuk memasukkan sebuah null reference, semata-mata karena itu terlalu mudah diimplementasikan. Hal ini telah menyebabkan kesalahan, kerentanan, dan crash sistem yang tak terhitung jumlahnya, yang mungkin telah menyebabkan penderitaan dan kerugian sen dolar miliar dalam empat puluh tahun terakhir.

Masalah dengan nilai null adalah jika kamu mencoba menggunakan nilai null sebagai nilai bukan-null, kamu akan mendapatkan error semacam ini. Karena sifat null atau bukan-null ini ada di mana-mana, sangatlah mudah untuk membuat kesalahan semacam ini.

Namun, konsep yang ingin diekspresikan oleh null tetap berguna: null adalah nilai yang saat ini tidak valid atau absen karena suatu alasan.

Masalahnya sebenarnya bukan pada konsepnya, melainkan pada implementasi khususnya. Karena itu, Rust tidak punya null, tetapi ia punya sebuah enum yang bisa mengodekan konsep keberadaan atau ketiadaan sebuah nilai. Enum ini adalah Option<T>, dan ia didefinisikan oleh standard library sebagai berikut:

#![allow(unused)]
fn main() {
enum Option<T> {
    None,
    Some(T),
}
}

Enum Option<T> sangat berguna sehingga ikut disertakan dalam prelude; kamu tidak perlu membawanya ke dalam scope secara eksplisit. Varian-variannya juga ikut disertakan dalam prelude: Kamu bisa langsung menggunakan Some dan None tanpa awalan Option::. Enum Option<T> tetap hanyalah enum biasa, dan Some(T) serta None tetap merupakan varian bertipe Option<T>.

Sintaks <T> adalah fitur Rust yang belum kita bicarakan. Ini adalah parameter tipe generic, dan kita akan membahas generic lebih rinci di Bab 10. Untuk sekarang, yang perlu kamu ketahui hanya bahwa <T> berarti varian Some dari enum Option bisa menampung satu buah data bertipe apa pun, dan bahwa setiap tipe konkret yang dipakai menggantikan T membuat keseluruhan tipe Option<T> menjadi tipe yang berbeda. Berikut beberapa contoh penggunaan nilai Option untuk menampung tipe angka dan tipe char:

fn main() {
    let some_number = Some(5);
    let some_char = Some('e');

    let absent_number: Option<i32> = None;
}

Tipe dari some_number adalah Option<i32>. Tipe dari some_char adalah Option<char>, yang merupakan tipe berbeda. Rust bisa menyimpulkan tipe-tipe ini karena kita telah menentukan sebuah nilai di dalam varian Some. Untuk absent_number, Rust mensyaratkan kita memberi anotasi tipe Option secara keseluruhan: Compiler tidak bisa menyimpulkan tipe yang akan dipegang oleh varian Some yang bersangkutan hanya dengan melihat nilai None. Di sini, kita memberi tahu Rust bahwa kita menginginkan absent_number bertipe Option<i32>.

Ketika kita punya nilai Some, kita tahu bahwa sebuah nilai ada, dan nilai tersebut dipegang di dalam Some itu. Ketika kita punya nilai None, dalam artian tertentu itu berarti hal yang sama dengan null: Kita tidak punya nilai yang valid. Lalu, mengapa memiliki Option<T> lebih baik daripada memiliki null?

Singkatnya, karena Option<T> dan T (di mana T bisa berupa tipe apa pun) adalah tipe yang berbeda, compiler tidak akan membiarkan kita menggunakan nilai Option<T> seolah-olah nilai itu pasti valid. Sebagai contoh, kode ini tidak akan mengompilasi, karena mencoba menambahkan i8 dengan Option<i8>:

fn main() {
    let x: i8 = 5;
    let y: Option<i8> = Some(5);

    let sum = x + y;
}

Jika kita menjalankan kode ini, kita akan mendapatkan pesan error seperti ini:

$ cargo run
   Compiling enums v0.1.0 (file:///projects/enums)
error[E0277]: cannot add `Option<i8>` to `i8`
 --> src/main.rs:5:17
  |
5 |     let sum = x + y;
  |                 ^ no implementation for `i8 + Option<i8>`
  |
  = help: the trait `Add<Option<i8>>` is not implemented for `i8`
help: the following other types implement trait `Add<Rhs>`
 --> /rustc/58cf8f9c35b355199727627d07ae34a4e2846d67/library/core/src/ops/arith.rs:98:8
  |
  = note: `i8` implements `Add`
 ::: /rustc/58cf8f9c35b355199727627d07ae34a4e2846d67/library/core/src/ops/arith.rs:113:0
  |
  = note: in this macro invocation
 --> /rustc/58cf8f9c35b355199727627d07ae34a4e2846d67/library/core/src/internal_macros.rs:22:8
  |
  = note: `&i8` implements `Add<i8>`
 ::: /rustc/58cf8f9c35b355199727627d07ae34a4e2846d67/library/core/src/internal_macros.rs:33:8
  |
  = note: `i8` implements `Add<&i8>`
 ::: /rustc/58cf8f9c35b355199727627d07ae34a4e2846d67/library/core/src/internal_macros.rs:44:8
  |
  = note: `&i8` implements `Add`
  = note: this error originates in the macro `add_impl` (in Nightly builds, run with -Z macro-backtrace for more info)

For more information about this error, try `rustc --explain E0277`.
error: could not compile `enums` (bin "enums") due to 1 previous error

Luar biasa! Pada dasarnya, pesan error ini berarti Rust tidak mengerti cara menambahkan i8 dengan Option<i8>, karena keduanya bertipe berbeda. Ketika kita punya nilai bertipe seperti i8 di Rust, compiler akan memastikan bahwa kita selalu punya nilai yang valid. Kita bisa melangkah dengan percaya diri tanpa harus memeriksa null sebelum menggunakan nilai tersebut. Baru ketika kita punya Option<i8> (atau tipe nilai apa pun yang sedang kita kerjakan) kita perlu khawatir soal kemungkinan tidak punya nilai, dan compiler akan memastikan kita menangani kasus tersebut sebelum menggunakan nilai itu.

Dengan kata lain, kamu harus mengonversi Option<T> menjadi T sebelum kamu bisa melakukan operasi T dengannya. Secara umum, ini membantu menangkap salah satu masalah paling umum dengan null: menganggap sesuatu bukan-null padahal sebenarnya null.

Menghilangkan risiko asumsi yang keliru terhadap sebuah nilai bukan-null membantu kamu lebih percaya diri dengan kodemu. Untuk punya nilai yang mungkin null, kamu harus secara eksplisit memilihnya dengan membuat tipe nilai tersebut menjadi Option<T>. Lalu, ketika kamu menggunakan nilai itu, kamu diwajibkan menangani secara eksplisit kasus ketika nilai tersebut null. Di mana pun sebuah nilai bertipe yang bukan Option<T>, kamu bisa dengan aman mengasumsikan bahwa nilai tersebut bukan-null. Ini adalah keputusan desain yang sengaja dibuat oleh Rust untuk membatasi penyebaran null dan meningkatkan keamanan kode Rust.

Lalu bagaimana kamu mengeluarkan nilai T dari varian Some ketika kamu punya nilai bertipe Option<T> agar bisa menggunakan nilai itu? Enum Option<T> punya sangat banyak method yang berguna untuk berbagai situasi; kamu bisa menjelajahinya di dokumentasinya. Membiasakan diri dengan method-method pada Option<T> akan sangat berguna dalam perjalananmu mempelajari Rust.

Secara umu, untuk menggunakan nilai Option<T>, kamu ingin punya kode yang menangani setiap varian. Kamu ingin kode yang hanya berjalan ketika kamu punya nilai Some(T), dan kode ini boleh menggunakan T di dalamnya. Kamu ingin kode lain yang hanya berjalan jika kamu punya nilai None, dan kode tersebut tidak punya nilai T yang tersedia. Ekspresi match adalah konstruk alur kontrol yang melakukan tepat hal itu ketika digunakan dengan enum: Ia akan menjalankan kode yang berbeda tergantung varian enum yang dimilikinya, dan kode tersebut bisa menggunakan data di dalam nilai yang cocok.