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

Error yang Bisa Dipulihkan dengan Result

Kebanyakan error tidak cukup serius sampai harus menghentikan program secara keseluruhan. Kadang, saat sebuah fungsi gagal, penyebabnya bisa kamu mengerti dan tangani dengan mudah. Misalnya, jika kamu mencoba membuka sebuah file dan operasi itu gagal karena file-nya tidak ada, kamu mungkin ingin membuat filenya alih-alih menghentikan proses.

Ingat dari “Menangani Kemungkinan Kegagalan dengan Result” di Bab 2 bahwa enum Result didefinisikan dengan dua varian, Ok dan Err, seperti berikut:

#![allow(unused)]
fn main() {
enum Result<T, E> {
    Ok(T),
    Err(E),
}
}

T dan E adalah parameter tipe generik: Kita akan membahas generic lebih detail di Bab 10. Yang perlu kamu tahu sekarang adalah T mewakili tipe nilai yang akan dikembalikan dalam kasus sukses di dalam varian Ok, dan E mewakili tipe error yang akan dikembalikan dalam kasus gagal di dalam varian Err. Karena Result punya parameter tipe generik ini, kita bisa memakai tipe Result dan fungsi-fungsi yang didefinisikan di atasnya dalam banyak situasi berbeda, di mana nilai sukses dan nilai error yang ingin kita kembalikan bisa berbeda.

Mari kita panggil sebuah fungsi yang mengembalikan nilai Result, karena fungsi itu bisa saja gagal. Pada Listing 9-3, kita mencoba membuka sebuah file.

Filename: src/main.rs
use std::fs::File;

fn main() {
    let greeting_file_result = File::open("hello.txt");
}
Listing 9-3: Membuka sebuah file

Tipe kembalian dari File::open adalah Result<T, E>. Parameter generik T sudah diisi oleh implementasi File::open dengan tipe nilai sukses, std::fs::File, yang merupakan sebuah handle file. Tipe E yang dipakai dalam nilai error adalah std::io::Error. Tipe kembalian ini berarti pemanggilan File::open bisa berhasil dan mengembalikan handle file yang bisa kita baca atau tulis. Pemanggilan fungsi itu juga bisa gagal: misalnya, file-nya mungkin tidak ada, atau kita mungkin tidak punya izin untuk mengaksesnya. Fungsi File::open perlu punya cara untuk memberi tahu kita apakah pemanggilan itu berhasil atau gagal, dan sekaligus memberi kita handle file atau informasi error. Informasi itulah yang justru disampaikan oleh enum Result.

Pada kasus saat File::open berhasil, nilai di dalam variabel greeting_file_result akan berupa sebuah instance Ok yang berisi handle file. Pada kasus saat gagal, nilai di greeting_file_result akan berupa sebuah instance Err yang berisi informasi lebih lanjut tentang jenis error yang terjadi.

Kita perlu menambahkan kode pada Listing 9-3 untuk mengambil tindakan yang berbeda bergantung pada nilai yang dikembalikan File::open. Listing 9-4 menunjukkan satu cara menangani Result memakai alat dasar, yaitu ekspresi match yang sudah kita bahas di Bab 6.

Filename: src/main.rs
use std::fs::File;

fn main() {
    let greeting_file_result = File::open("hello.txt");

    let greeting_file = match greeting_file_result {
        Ok(file) => file,
        Err(error) => panic!("Problem opening the file: {error:?}"),
    };
}
Listing 9-4: Memakai ekspresi match untuk menangani varian Result yang mungkin dikembalikan

Perhatikan bahwa, seperti enum Option, enum Result dan varian-variannya sudah dimasukkan ke dalam scope oleh prelude, jadi kita tidak perlu menuliskan Result:: sebelum varian Ok dan Err di cabang-cabang match.

Saat hasilnya Ok, kode ini akan mengembalikan nilai file di dalam varian Ok, lalu kita menetapkan nilai handle file itu ke variabel greeting_file. Setelah match, kita bisa memakai handle file tersebut untuk membaca atau menulis.

Cabang match yang lain menangani kasus saat kita mendapat nilai Err dari File::open. Pada contoh ini, kita memilih untuk memanggil macro panic!. Jika tidak ada file bernama hello.txt di direktori saat ini dan kita menjalankan kode ini, kita akan melihat keluaran berikut dari macro panic!:

$ cargo run
   Compiling error-handling v0.1.0 (file:///projects/error-handling)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.73s
     Running `target/debug/error-handling`

thread 'main' (6018048) panicked at src/main.rs:8:23:
Problem opening the file: Os { code: 2, kind: NotFound, message: "No such file or directory" }
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Seperti biasa, keluaran ini memberi tahu kita dengan tepat apa yang salah.

Mencocokkan Berbagai Jenis Error

Kode di Listing 9-4 akan panic! tidak peduli mengapa File::open gagal. Namun, kita ingin mengambil tindakan berbeda untuk alasan kegagalan yang berbeda. Jika File::open gagal karena file-nya tidak ada, kita ingin membuat filenya dan mengembalikan handle ke file baru itu. Jika File::open gagal karena alasan lain—misalnya karena kita tidak punya izin untuk membuka file-nya—kita tetap ingin kode-nya panic! dengan cara yang sama seperti di Listing 9-4. Untuk itu, kita menambahkan ekspresi match di dalam, seperti yang ditunjukkan Listing 9-5.

Filename: src/main.rs
use std::fs::File;
use std::io::ErrorKind;

fn main() {
    let greeting_file_result = File::open("hello.txt");

    let greeting_file = match greeting_file_result {
        Ok(file) => file,
        Err(error) => match error.kind() {
            ErrorKind::NotFound => match File::create("hello.txt") {
                Ok(fc) => fc,
                Err(e) => panic!("Problem creating the file: {e:?}"),
            },
            _ => {
                panic!("Problem opening the file: {error:?}");
            }
        },
    };
}
Listing 9-5: Menangani berbagai jenis error dengan cara yang berbeda

Tipe nilai yang dikembalikan File::open di dalam varian Err adalah io::Error, sebuah struct yang disediakan oleh standard library. Struct ini punya sebuah method, kind, yang bisa kita panggil untuk mendapatkan nilai io::ErrorKind. Enum io::ErrorKind disediakan oleh standard library dan mempunyai varian-varian yang mewakili berbagai jenis error yang mungkin dihasilkan oleh operasi io. Varian yang ingin kita pakai adalah ErrorKind::NotFound, yang menandakan file yang ingin kita buka belum ada. Jadi, kita mencocokkan greeting_file_result, tetapi kita juga punya match di dalam untuk error.kind().

Kondisi yang ingin kita cek di match dalam adalah apakah nilai yang dikembalikan oleh error.kind() adalah varian NotFound dari enum ErrorKind. Jika ya, kita mencoba membuat filenya dengan File::create. Namun, karena File::create juga bisa gagal, kita butuh cabang kedua dalam ekspresi match dalam itu. Saat file tidak bisa dibuat, pesan error yang berbeda akan dicetak. Cabang kedua dari match luar tetap sama, sehingga program melakukan panic pada error apa pun selain error file tidak ditemukan.

Alternatif Memakai match dengan Result<T, E>

Itu match yang cukup banyak! Ekspresi match sangat berguna, tetapi juga tergolong primitif. Di Bab 13, kamu akan belajar tentang closure, yang dipakai bersama banyak method yang didefinisikan pada Result<T, E>. Method-method ini bisa lebih ringkas daripada memakai match saat menangani nilai Result<T, E> dalam kode kamu.

Misalnya, ini cara lain untuk menulis logika yang sama seperti di Listing 9-5, kali ini memakai closure dan method unwrap_or_else:

use std::fs::File;
use std::io::ErrorKind;

fn main() {
    let greeting_file = File::open("hello.txt").unwrap_or_else(|error| {
        if error.kind() == ErrorKind::NotFound {
            File::create("hello.txt").unwrap_or_else(|error| {
                panic!("Problem creating the file: {error:?}");
            })
        } else {
            panic!("Problem opening the file: {error:?}");
        }
    });
}

Meski kode ini punya perilaku yang sama dengan Listing 9-5, kode ini tidak memuat ekspresi match apa pun dan lebih bersih dibaca. Kembali ke contoh ini setelah kamu membaca Bab 13 dan lihat method unwrap_or_else dalam dokumentasi standard library. Masih banyak method lain seperti ini yang bisa merapikan ekspresi match bertingkat yang besar saat kamu menangani error.

Jalan Pintas untuk Panic saat Error

Memakai match sudah cukup baik, tetapi bisa agak panjang dan tidak selalu menyampaikan maksud dengan jelas. Tipe Result<T, E> punya banyak method pembantu yang didefinisikan di atasnya untuk melakukan berbagai tugas yang lebih spesifik. Method unwrap adalah method jalan pintas yang diimplementasikan persis seperti ekspresi match yang kita tulis di Listing 9-4. Jika nilai Result adalah varian Ok, unwrap akan mengembalikan nilai di dalam Ok. Jika Result adalah varian Err, unwrap akan memanggil macro panic! untuk kita. Berikut contoh unwrap dalam aksi:

Filename: src/main.rs
use std::fs::File;

fn main() {
    let greeting_file = File::open("hello.txt").unwrap();
}

Jika kita menjalankan kode ini tanpa file hello.txt, kita akan melihat pesan error dari pemanggilan panic! yang dilakukan method unwrap:

thread 'main' panicked at src/main.rs:4:49:
called `Result::unwrap()` on an `Err` value: Os { code: 2, kind: NotFound, message: "No such file or directory" }

Demikian pula, method expect memungkinkan kita juga memilih pesan error panic!. Memakai expect alih-alih unwrap serta memberikan pesan error yang bagus bisa menyampaikan maksud kamu dan memudahkan pelacakan sumber panic. Sintaks expect terlihat seperti ini:

Filename: src/main.rs
use std::fs::File;

fn main() {
    let greeting_file = File::open("hello.txt")
        .expect("hello.txt should be included in this project");
}

Kita memakai expect dengan cara yang sama seperti unwrap: untuk mengembalikan handle file atau memanggil macro panic!. Pesan error yang dipakai expect dalam pemanggilan panic!-nya akan berupa parameter yang kita berikan ke expect, alih-alih pesan panic! bawaan yang dipakai unwrap. Berikut tampilannya:

thread 'main' panicked at src/main.rs:5:10:
hello.txt should be included in this project: Os { code: 2, kind: NotFound, message: "No such file or directory" }

Pada kode siap produksi, kebanyakan Rustacean memilih expect daripada unwrap dan memberikan lebih banyak konteks tentang mengapa suatu operasi diharapkan selalu berhasil. Dengan begitu, jika asumsi kamu ternyata salah, kamu punya lebih banyak informasi untuk dipakai saat melakukan debug.

Menyebarkan Error

Saat implementasi sebuah fungsi memanggil sesuatu yang bisa gagal, alih-alih menangani error itu di dalam fungsi tersebut, kamu bisa mengembalikan error itu ke kode pemanggil agar kode itulah yang memutuskan apa yang harus dilakukan. Ini dikenal dengan menyebarkan error dan memberi lebih banyak kendali kepada kode pemanggil, di mana mungkin ada lebih banyak informasi atau logika yang menentukan bagaimana error sebaiknya ditangani daripada yang tersedia dalam konteks kode kamu.

Misalnya, Listing 9-6 menunjukkan sebuah fungsi yang membaca nama pengguna dari sebuah file. Jika file-nya tidak ada atau tidak bisa dibaca, fungsi ini akan mengembalikan error-error itu ke kode yang memanggil fungsi tersebut.

Filename: src/main.rs
#![allow(unused)]
fn main() {
use std::fs::File;
use std::io::{self, Read};

fn read_username_from_file() -> Result<String, io::Error> {
    let username_file_result = File::open("hello.txt");

    let mut username_file = match username_file_result {
        Ok(file) => file,
        Err(e) => return Err(e),
    };

    let mut username = String::new();

    match username_file.read_to_string(&mut username) {
        Ok(_) => Ok(username),
        Err(e) => Err(e),
    }
}
}
Listing 9-6: Sebuah fungsi yang mengembalikan error ke kode pemanggil memakai match

Fungsi ini bisa ditulis dengan jauh lebih pendek, tetapi kita akan mulai dengan melakukan banyak hal secara manual untuk menjelajahi penanganan error; pada akhirnya, kita akan menunjukkan cara yang lebih pendek. Mari kita lihat dulu tipe kembalian fungsinya: Result<String, io::Error>. Ini berarti fungsi itu mengembalikan nilai bertipe Result<T, E>, di mana parameter generik T sudah diisi dengan tipe konkret String dan parameter tipe generik E sudah diisi dengan tipe konkret io::Error.

Jika fungsi ini berhasil tanpa masalah, kode yang memanggil fungsi ini akan menerima nilai Ok yang berisi sebuah String—username yang dibaca fungsi ini dari file. Jika fungsi ini mengalami masalah, kode pemanggil akan menerima nilai Err yang berisi sebuah instance io::Error dengan informasi lebih lanjut tentang masalahnya. Kita memilih io::Error sebagai tipe kembalian fungsi ini karena kebetulan itulah tipe nilai error yang dikembalikan oleh kedua operasi yang kita panggil dalam tubuh fungsi ini dan bisa gagal: fungsi File::open dan method read_to_string.

Tubuh fungsi dimulai dengan memanggil fungsi File::open. Lalu, kita menangani nilai Result dengan match yang mirip dengan match di Listing 9-4. Jika File::open berhasil, handle file dalam variabel pattern file menjadi nilai di variabel mutable username_file, dan fungsi pun berlanjut. Pada kasus Err, alih-alih memanggil panic!, kita memakai keyword return untuk kembali lebih awal dari seluruh fungsi dan meneruskan nilai error dari File::open, yang kini ada di variabel pattern e, kembali ke kode pemanggil sebagai nilai error fungsi ini.

Jadi, jika kita punya handle file di username_file, fungsi lalu membuat String baru di variabel username dan memanggil method read_to_string pada handle file di username_file untuk membaca isi file ke dalam username. Method read_to_string juga mengembalikan Result karena bisa gagal, meskipun File::open sudah berhasil. Jadi, kita butuh match lain untuk menangani Result itu: Jika read_to_string berhasil, maka fungsi kita berhasil, dan kita mengembalikan username dari file yang sekarang ada di username dalam bungkus Ok. Jika read_to_string gagal, kita mengembalikan nilai error dengan cara yang sama seperti kita mengembalikan nilai error pada match yang menangani kembalian File::open. Namun, kita tidak perlu secara eksplisit menuliskan return, karena ini adalah ekspresi terakhir dalam fungsi.

Kode yang memanggil kode ini lalu akan menangani apakah ia mendapat nilai Ok yang berisi username atau nilai Err yang berisi io::Error. Terserah kode pemanggil untuk memutuskan apa yang harus dilakukan dengan nilai-nilai itu. Jika kode pemanggil mendapat nilai Err, kode itu bisa memanggil panic! dan meng crash program, memakai username bawaan, atau mencari username dari tempat lain selain file, misalnya. Kita tidak punya cukup informasi tentang apa yang sebenarnya sedang dilakukan kode pemanggil, jadi kita menyebarkan semua informasi sukses atau error ke atas agar kode itulah yang menangani dengan tepat.

Pola penyebaran error ini sangat umum di Rust, sampai-sampai Rust menyediakan operator tanya ? untuk memudahkannya.

Jalan Pintas Operator ? untuk Menyebarkan Error

Listing 9-7 menunjukkan implementasi read_username_from_file yang punya fungsionalitas sama seperti di Listing 9-6, tetapi implementasi ini memakai operator ?.

Filename: src/main.rs
#![allow(unused)]
fn main() {
use std::fs::File;
use std::io::{self, Read};

fn read_username_from_file() -> Result<String, io::Error> {
    let mut username_file = File::open("hello.txt")?;
    let mut username = String::new();
    username_file.read_to_string(&mut username)?;
    Ok(username)
}
}
Listing 9-7: Sebuah fungsi yang mengembalikan error ke kode pemanggil memakai operator ?

? yang ditempatkan setelah nilai Result didefinisikan untuk bekerja hampir sama seperti ekspresi match yang kita buat untuk menangani nilai Result di Listing 9-6. Jika nilai Result adalah Ok, nilai di dalam Ok akan dikembalikan dari ekspresi ini, dan program pun berlanjut. Jika nilainya Err, maka Err akan dikembalikan dari seluruh fungsi seolah-olah kita memakai keyword return, sehingga nilai error tersebut tersebar ke kode pemanggil.

Ada perbedaan antara apa yang dilakukan ekspresi match di Listing 9-6 dan apa yang dilakukan operator ?: Nilai error yang dikenai operator ? melewati fungsi from, yang didefinisikan dalam trait From di standard library dan dipakai untuk mengonversi nilai dari satu tipe ke tipe lain. Saat operator ? memanggil fungsi from, tipe error yang diterima dikonversi menjadi tipe error yang didefinisikan dalam tipe kembalian fungsi saat ini. Ini berguna saat sebuah fungsi mengembalikan satu tipe error untuk mewakili semua cara fungsi itu bisa gagal, meskipun bagian-bagian tertentu bisa gagal karena banyak alasan berbeda.

Misalnya, kita bisa mengubah fungsi read_username_from_file di Listing 9-7 agar mengembalikan tipe error kustom bernama OurError yang kita definisikan. Jika kita juga mendefinisikan impl From<io::Error> for OurError untuk membangun sebuah instance OurError dari sebuah io::Error, maka pemanggilan operator ? dalam tubuh read_username_from_file akan memanggil from dan mengonversi tipe-tipe error tanpa perlu menambah kode apa pun ke dalam fungsi.

Dalam konteks Listing 9-7, ? di akhir pemanggilan File::open akan mengembalikan nilai di dalam Ok ke variabel username_file. Jika terjadi error, operator ? akan kembali lebih awal dari seluruh fungsi dan memberikan nilai Err apa pun ke kode pemanggil. Hal yang sama berlaku untuk ? di akhir pemanggilan read_to_string.

Operator ? menghilangkan banyak boilerplate dan membuat implementasi fungsi ini lebih sederhana. Kita bahkan bisa mempersingkat kode ini lebih jauh dengan merangkai pemanggilan method tepat setelah ?, seperti yang ditunjukkan Listing 9-8.

Filename: src/main.rs
#![allow(unused)]
fn main() {
use std::fs::File;
use std::io::{self, Read};

fn read_username_from_file() -> Result<String, io::Error> {
    let mut username = String::new();

    File::open("hello.txt")?.read_to_string(&mut username)?;

    Ok(username)
}
}
Listing 9-8: Merangkai pemanggilan method setelah operator ?

Kita memindahkan pembuatan String baru di username ke awal fungsi; bagian itu tidak berubah. Alih-alih membuat variabel username_file, kita merangkai pemanggilan read_to_string langsung ke hasil dari File::open("hello.txt")?. Kita tetap punya ? di akhir pemanggilan read_to_string, dan kita tetap mengembalikan nilai Ok yang berisi username saat File::open dan read_to_string keduanya berhasil alih-alih mengembalikan error. Fungsionalitasnya sekali lagi sama seperti di Listing 9-6 dan Listing 9-7; ini hanya cara lain yang lebih ergonomis untuk menuliskannya.

Listing 9-9 menunjukkan cara membuat ini bahkan lebih pendek dengan memakai fs::read_to_string.

Filename: src/main.rs
#![allow(unused)]
fn main() {
use std::fs;
use std::io;

fn read_username_from_file() -> Result<String, io::Error> {
    fs::read_to_string("hello.txt")
}
}
Listing 9-9: Memakai fs::read_to_string alih-alih membuka lalu membaca file

Membaca sebuah file ke dalam string adalah operasi yang cukup umum, sehingga standard library menyediakan fungsi fs::read_to_string yang praktis, yang membuka file, membuat String baru, membaca isi file, memasukkan isinya ke dalam String itu, dan mengembalikannya. Tentu saja, memakai fs::read_to_string tidak memberi kita kesempatan untuk menjelaskan semua penanganan error, itulah sebabnya kita melakukannya dengan cara panjang terlebih dahulu.

Di Mana Operator ? Bisa Dipakai

Operator ? hanya bisa dipakai dalam fungsi yang tipe kembaliannya kompatibel dengan nilai yang dikenai ?. Ini karena operator ? didefinisikan untuk melakukan pengembalian awal sebuah nilai dari fungsi, dengan cara yang sama seperti ekspresi match yang kita buat di Listing 9-6. Di Listing 9-6, match memakai nilai Result, dan cabang pengembalian awalnya mengembalikan nilai Err(e). Tipe kembalian fungsi haruslah sebuah Result agar kompatibel dengan return ini.

Di Listing 9-10, mari kita lihat error yang akan kita dapatkan jika memakai operator ? dalam fungsi main dengan tipe kembalian yang tidak kompatibel dengan tipe nilai yang kita kenai ?.

Filename: src/main.rs
use std::fs::File;

fn main() {
    let greeting_file = File::open("hello.txt")?;
}
Listing 9-10: Mencoba memakai ? dalam fungsi main yang mengembalikan () tidak akan terkompilasi.

Kode ini membuka sebuah file, yang bisa saja gagal. Operator ? mengikuti nilai Result yang dikembalikan File::open, tetapi fungsi main ini punya tipe kembalian (), bukan Result. Saat kita mengompilasi kode ini, kita mendapat pesan error berikut:

$ cargo run
   Compiling error-handling v0.1.0 (file:///projects/error-handling)
error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
 --> src/main.rs:4:48
  |
3 | fn main() {
  | --------- this function should return `Result` or `Option` to accept `?`
4 |     let greeting_file = File::open("hello.txt")?;
  |                                                ^ cannot use the `?` operator in a function that returns `()`
  |
help: consider adding return type
  |
3 ~ fn main() -> Result<(), Box<dyn std::error::Error>> {
4 |     let greeting_file = File::open("hello.txt")?;
5 +     Ok(())
  |

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

Error ini menunjukkan bahwa kita hanya boleh memakai operator ? dalam fungsi yang mengembalikan Result, Option, atau tipe lain yang mengimplementasikan FromResidual.

Untuk memperbaiki error itu, kamu punya dua pilihan. Salah satu pilihannya adalah mengubah tipe kembalian fungsimu agar kompatibel dengan nilai yang kamu kenai operator ?, selama tidak ada pembatasan yang melarangnya. Pilihan lainnya adalah memakai match atau salah satu method Result<T, E> untuk menangani Result<T, E> dengan cara yang sesuai.

Pesan error itu juga menyebutkan bahwa ? bisa dipakai dengan nilai Option<T> juga. Sama seperti memakai ? pada Result, kamu hanya bisa memakai ? pada Option dalam fungsi yang mengembalikan Option. Perilaku operator ? saat dipakai pada Option<T> mirip dengan perilakunya saat dipakai pada Result<T, E>: Jika nilainya None, maka None akan dikembalikan lebih awal dari fungsi pada titik itu. Jika nilainya Some, nilai di dalam Some adalah nilai hasil dari ekspresi tersebut, dan fungsi pun berlanjut. Listing 9-11 punya contoh fungsi yang mencari karakter terakhir dari baris pertama dalam teks yang diberikan.

fn last_char_of_first_line(text: &str) -> Option<char> {
    text.lines().next()?.chars().last()
}

fn main() {
    assert_eq!(
        last_char_of_first_line("Hello, world\nHow are you today?"),
        Some('d')
    );

    assert_eq!(last_char_of_first_line(""), None);
    assert_eq!(last_char_of_first_line("\nhi"), None);
}
Listing 9-11: Memakai operator ? pada nilai Option<T>

Fungsi ini mengembalikan Option<char> karena memungkinkan ada karakter di sana, tetapi juga memungkinkan tidak ada. Kode ini mengambil argumen string slice text dan memanggil method lines padanya, yang mengembalikan sebuah iterator atas baris-baris dalam string. Karena fungsi ini ingin memeriksa baris pertama, fungsi memanggil next pada iterator itu untuk mendapatkan nilai pertama darinya. Jika text adalah string kosong, pemanggilan next ini akan mengembalikan None, dan dalam hal itu kita memakai ? untuk berhenti dan mengembalikan None dari last_char_of_first_line. Jika text bukan string kosong, next akan mengembalikan nilai Some yang berisi string slice dari baris pertama dalam text.

? mengekstrak string slice itu, dan kita bisa memanggil chars pada string slice tersebut untuk mendapatkan iterator atas karakter-karakterannya. Kita tertarik pada karakter terakhir di baris pertama ini, jadi kita memanggil last untuk mengembalikan item terakhir dalam iterator. Ini adalah Option karena memungkinkan baris pertama adalah string kosong; misalnya, jika text diawali dengan baris kosong tetapi punya karakter di baris lain, seperti "\nhi". Namun, jika ada karakter terakhir di baris pertama, karakter itu akan dikembalikan dalam varian Some. Operator ? di tengah memberi kita cara ringkas untuk menyatakan logika ini, memungkinkan kita mengimplementasikan fungsi dalam satu baris. Seandainya kita tidak bisa memakai operator ? pada Option, kita harus mengimplementasikan logika ini dengan lebih banyak pemanggilan method atau sebuah ekspresi match.

Perhatikan bahwa kamu bisa memakai operator ? pada sebuah Result dalam fungsi yang mengembalikan Result, dan kamu bisa memakai operator ? pada sebuah Option dalam fungsi yang mengembalikan Option, tetapi kamu tidak bisa mencampur-adukkannya. Operator ? tidak akan otomatis mengonversi Result menjadi Option atau sebaliknya; dalam kasus seperti itu, kamu bisa memakai method seperti method ok pada Result atau method ok_or pada Option untuk melakukan konversi secara eksplisit.

Sejauh ini, semua fungsi main yang kita pakai mengembalikan (). Fungsi main bersifat khusus karena merupakan titik masuk dan titik keluar dari sebuah program yang dapat dijalankan, dan ada batasan tentang apa yang boleh menjadi tipe kembaliannya agar program berperilaku seperti yang diharapkan.

Untungnya, main juga bisa mengembalikan Result<(), E>. Listing 9-12 memuat kode dari Listing 9-10, tetapi kita sudah mengubah tipe kembalian main menjadi Result<(), Box<dyn Error>> dan menambahkan nilai kembalian Ok(()) di akhir. Kode ini sekarang akan terkompilasi.

Filename: src/main.rs
use std::error::Error;
use std::fs::File;

fn main() -> Result<(), Box<dyn Error>> {
    let greeting_file = File::open("hello.txt")?;

    Ok(())
}
Listing 9-12: Mengubah main agar mengembalikan Result<(), E> membolehkan pemakaian operator ? pada nilai Result.

Tipe Box<dyn Error> adalah sebuah trait object, yang akan kita bahas dalam “Memakai Trait Object untuk Abstraksi atas Perilaku Bersama” di Bab 18. Untuk sementara, kamu bisa membaca Box<dyn Error> sebagai “jenis error apa pun.” Memakai ? pada nilai Result dalam fungsi main dengan tipe error Box<dyn Error> dibolehkan karena tipe itu membolehkan nilai Err apa pun dikembalikan lebih awal. Meskipun tubuh fungsi main ini hanya akan pernah mengembalikan error bertipe std::io::Error, dengan menentukan Box<dyn Error>, tanda tangan ini akan tetap benar bahkan jika lebih banyak kode yang mengembalikan error lain ditambahkan ke tubuh main.

Saat sebuah fungsi main mengembalikan Result<(), E>, program yang dapat dijalankan akan keluar dengan nilai 0 jika main mengembalikan Ok(()) dan akan keluar dengan nilai bukan nol jika main mengembalikan nilai Err. Program yang dapat dijalankan yang ditulis dalam C mengembalikan bilangan bulat saat keluar: Program yang keluar dengan sukses mengembalikan bilangan bulat 0, dan program yang mengalami error mengembalikan bilangan bulat selain 0. Rust juga mengembalikan bilangan bulat dari program yang dapat dijalankan agar kompatibel dengan konvensi ini.

Fungsi main boleh mengembalikan tipe apa pun yang mengimplementasikan trait std::process::Termination, yang memuat sebuah fungsi report yang mengembalikan ExitCode. Konsultasikan dokumentasi standard library untuk informasi lebih lanjut tentang mengimplementasikan trait Termination bagi tipe-tipe kamu sendiri.

Sekarang setelah kita membahas detail tentang memanggil panic! atau mengembalikan Result, mari kita kembali ke topik tentang cara memutuskan mana yang tepat dipakai dalam kasus yang mana.