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

Tipe Lanjutan

Sistem tipe Rust punya beberapa fitur yang sudah kita sebutkan sebelumnya tetapi belum kita bahas. Kita akan mulai dengan membahas newtype secara umum sambil melihat mengapa tipe-tipe itu berguna. Setelah itu, kita beralih ke alias tipe, fitur yang mirip dengan newtype tetapi dengan semantik yang sedikit beda. Kita juga akan membahas tipe ! dan tipe yang ukurannya ditentukan saat runtime.

Keamanan Tipe dan Abstraksi dengan Pola Newtype

Bagian ini mengasumsikan kamu sudah membaca bagian sebelumnya, “Mengimplementasikan Trait Eksternal dengan Pola Newtype”. Pola newtype juga berguna untuk tugas-tugas di luar yang sudah kita bahas sejauh ini, termasuk memberlakukan secara statis bahwa nilai-nilai tidak pernah tertukar dan menunjukkan satuan dari sebuah nilai. Kamu sudah melihat contoh penggunaan newtype untuk menunjukkan satuan di Listing 20-16: Ingat bahwa struct Millimeters dan Meters membungkus nilai u32 di dalam newtype. Jika kita menulis fungsi dengan parameter bertipe Millimeters, kita tidak bisa mengompilasi program yang tanpa sengaja mencoba memanggil fungsi itu dengan nilai bertipe Meters atau u32 biasa.

Kita juga bisa memakai pola newtype untuk menyembunyikan beberapa detail implementasi dari sebuah tipe: Tipe baru itu bisa mengekspos API publik yang berbeda dari API tipe dalam yang bersifat private.

Newtype juga bisa menyembunyikan implementasi internal. Misalnya, kita bisa menyediakan tipe People untuk membungkus HashMap<i32, String> yang menyimpan ID seseorang yang dikaitkan dengan namanya. Kode yang memakai People hanya akan berinteraksi dengan API publik yang kita sediakan, seperti metode untuk menambahkan string nama ke dalam koleksi People; kode itu tidak perlu tahu bahwa kita secara internal memberi ID i32 pada nama. Pola newtype adalah cara ringan untuk mencapai enkapsulasi guna menyembunyikan detail implementasi, yang sudah kita bahas di bagian “Enkapsulasi yang Menyembunyikan Detail Implementasi” di Bab 18.

Sinonim Tipe dan Alias Tipe

Rust menyediakan kemampuan untuk mendeklarasikan alias tipe agar sebuah tipe yang sudah ada punya nama lain. Untuk itu kita memakai keyword type. Misalnya, kita bisa membuat alias Kilometers untuk i32 seperti ini:

fn main() {
    type Kilometers = i32;

    let x: i32 = 5;
    let y: Kilometers = 5;

    println!("x + y = {}", x + y);
}

Sekarang alias Kilometers adalah sinonim untuk i32; tidak seperti tipe Millimeters dan Meters yang kita buat di Listing 20-16, Kilometers bukan tipe baru yang terpisah. Nilai-nilai yang bertipe Kilometers akan diperlakukan sama seperti nilai bertipe i32:

fn main() {
    type Kilometers = i32;

    let x: i32 = 5;
    let y: Kilometers = 5;

    println!("x + y = {}", x + y);
}

Karena Kilometers dan i32 adalah tipe yang sama, kita bisa menjumlahkan nilai dari kedua tipe itu dan bisa mengoper nilai Kilometers ke fungsi yang menerima parameter i32. Akan tetapi, dengan cara ini kita tidak mendapatkan manfaat pemeriksaan tipe yang kita peroleh dari pola newtype yang dibahas sebelumnya. Dengan kata lain, jika kita mencampuradukkan nilai Kilometers dan i32 di suatu tempat, compiler tidak akan memberi kita error.

Kasus penggunaan utama sinonim tipe adalah mengurangi pengulangan. Misalnya, kita mungkin punya tipe yang panjang seperti ini:

Box<dyn Fn() + Send + 'static>

Menulis tipe panjang itu di signature fungsi dan sebagai anotasi tipe di seluruh kode bisa melelahkan dan rawan salah. Bayangkan sebuah proyek yang penuh dengan kode seperti di Listing 20-25.

fn main() {
    let f: Box<dyn Fn() + Send + 'static> = Box::new(|| println!("hi"));

    fn takes_long_type(f: Box<dyn Fn() + Send + 'static>) {
        // --snip--
    }

    fn returns_long_type() -> Box<dyn Fn() + Send + 'static> {
        // --snip--
        Box::new(|| ())
    }
}
Listing 20-25: Memakai tipe panjang di banyak tempat

Alias tipe membuat kode ini lebih mudah dikelola dengan mengurangi pengulangan. Di Listing 20-26, kita memperkenalkan alias bernama Thunk untuk tipe yang panjang itu, lalu bisa mengganti semua pemakaian tipe tersebut dengan alias yang lebih pendek, Thunk.

fn main() {
    type Thunk = Box<dyn Fn() + Send + 'static>;

    let f: Thunk = Box::new(|| println!("hi"));

    fn takes_long_type(f: Thunk) {
        // --snip--
    }

    fn returns_long_type() -> Thunk {
        // --snip--
        Box::new(|| ())
    }
}
Listing 20-26: Memperkenalkan alias tipe, Thunk, untuk mengurangi pengulangan

Kode ini jauh lebih mudah dibaca dan ditulis! Memilih nama yang bermakna untuk alias tipe juga bisa membantu menyampaikan maksud kamu (thunk adalah istilah untuk kode yang akan dievaluasi nanti, jadi nama itu pas untuk closure yang disimpan).

Alias tipe juga umum dipakai bersama tipe Result<T, E> untuk mengurangi pengulangan. Perhatikan module std::io di pustaka standar. Operasi I/O sering mengembalikan Result<T, E> untuk menangani situasi ketika operasi gagal. Pustaka ini punya struct std::io::Error yang mewakili semua kemungkinan error I/O. Banyak fungsi di std::io akan mengembalikan Result<T, E> dengan E berupa std::io::Error, seperti fungsi-fungsi berikut di trait Write:

use std::fmt;
use std::io::Error;

pub trait Write {
    fn write(&mut self, buf: &[u8]) -> Result<usize, Error>;
    fn flush(&mut self) -> Result<(), Error>;

    fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>;
    fn write_fmt(&mut self, fmt: fmt::Arguments) -> Result<(), Error>;
}

Result<..., Error> diulang berkali-kali. Karena itu, std::io punya deklarasi alias tipe ini:

use std::fmt;

type Result<T> = std::result::Result<T, std::io::Error>;

pub trait Write {
    fn write(&mut self, buf: &[u8]) -> Result<usize>;
    fn flush(&mut self) -> Result<()>;

    fn write_all(&mut self, buf: &[u8]) -> Result<()>;
    fn write_fmt(&mut self, fmt: fmt::Arguments) -> Result<()>;
}

Karena deklarasi ini berada di module std::io, kita bisa memakai alias yang sepenuhnya memenuhi syarat, std::io::Result<T>; yaitu Result<T, E> dengan E diisi sebagai std::io::Error. Signature fungsi di trait Write akhirnya terlihat seperti ini:

use std::fmt;

type Result<T> = std::result::Result<T, std::io::Error>;

pub trait Write {
    fn write(&mut self, buf: &[u8]) -> Result<usize>;
    fn flush(&mut self) -> Result<()>;

    fn write_all(&mut self, buf: &[u8]) -> Result<()>;
    fn write_fmt(&mut self, fmt: fmt::Arguments) -> Result<()>;
}

Alias tipe membantu dalam dua cara: kode jadi lebih mudah ditulis dan kita mendapatkan antarmuka yang konsisten di seluruh std::io. Karena ini adalah alias, tipe itu hanyalah Result<T, E> lain, yang berarti kita bisa memakai metode apa pun yang bekerja pada Result<T, E> dengannya, serta sintaks khusus seperti operator ?.

Tipe Never yang Tidak Pernah Kembali

Rust punya tipe khusus bernama ! yang dalam istilah teori tipe disebut tipe kosong karena tidak punya nilai sama sekali. Kita lebih suka menyebutnya tipe never karena tipe ini berdiri di tempat tipe kembalian ketika sebuah fungsi tidak akan pernah kembali. Berikut contohnya:

fn bar() -> ! {
    // --snip--
    panic!();
}

Kode ini dibaca sebagai “fungsi bar tidak pernah kembali.” Fungsi yang tidak pernah kembali disebut fungsi yang divergen. Kita tidak bisa membuat nilai bertipe !, jadi bar tidak mungkin kembali.

Tapi apa gunanya tipe yang tidak bisa kita buat nilainya? Ingat kode di Listing 2-5, bagian dari game tebak angka; kita sajikan kembali sebagiannya di Listing 20-27.

use std::cmp::Ordering;
use std::io;

use rand::prelude::*;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::rng().random_range(1..=100);

    println!("The secret number is: {secret_number}");

    loop {
        println!("Please input your guess.");

        let mut guess = String::new();

        // --snip--

        io::stdin()
            .read_line(&mut guess)
            .expect("Failed to read line");

        let guess: u32 = match guess.trim().parse() {
            Ok(num) => num,
            Err(_) => continue,
        };

        println!("You guessed: {guess}");

        // --snip--

        match guess.cmp(&secret_number) {
            Ordering::Less => println!("Too small!"),
            Ordering::Greater => println!("Too big!"),
            Ordering::Equal => {
                println!("You win!");
                break;
            }
        }
    }
}
Listing 20-27: Sebuah match dengan cabang yang diakhiri continue

Saat itu, kita melewati beberapa detail dalam kode ini. Di bagian “Kontrol Alur match” di Bab 6, kita sudah membahas bahwa semua cabang match harus mengembalikan tipe yang sama. Jadi, misalnya, kode berikut tidak bekerja:

fn main() {
    let guess = "3";
    let guess = match guess.trim().parse() {
        Ok(_) => 5,
        Err(_) => "hello",
    };
}

Tipe guess dalam kode ini seharusnya harus berupa integer dan string, sementara Rust mengharuskan guess hanya punya satu tipe. Jadi, apa yang dikembalikan continue? Bagaimana kita bisa mengembalikan u32 dari satu cabang dan memiliki cabang lain yang diakhiri continue di Listing 20-27?

Seperti yang mungkin sudah kamu duga, continue punya nilai !. Artinya, saat Rust menghitung tipe guess, ia melihat kedua cabang match, yang pertama dengan nilai u32 dan yang kedua dengan nilai !. Karena ! tidak mungkin punya nilai, Rust memutuskan bahwa tipe guess adalah u32.

Cara formal untuk menggambarkan perilaku ini adalah ekspresi bertipe ! bisa dipaksa menjadi tipe lain apa pun. Kita boleh mengakhiri cabang match ini dengan continue karena continue tidak mengembalikan nilai; sebagai gantinya, ia mengembalikan kendali ke bagian atas loop, sehingga dalam kasus Err, kita tidak pernah memberi nilai pada guess.

Tipe never juga berguna bersama macro panic!. Ingat fungsi unwrap yang kita panggil pada nilai Option<T> untuk menghasilkan sebuah nilai atau panic, dengan definisi berikut:

enum Option<T> {
    Some(T),
    None,
}

use crate::Option::*;

impl<T> Option<T> {
    pub fn unwrap(self) -> T {
        match self {
            Some(val) => val,
            None => panic!("called `Option::unwrap()` on a `None` value"),
        }
    }
}

Dalam kode ini, hal yang sama terjadi seperti pada match di Listing 20-27: Rust melihat bahwa val bertipe T dan panic! bertipe !, sehingga hasil dari seluruh ekspresi match adalah T. Kode ini bekerja karena panic! tidak menghasilkan nilai; ia mengakhiri program. Dalam kasus None, kita tidak akan mengembalikan nilai dari unwrap, jadi kode ini valid.

Satu ekspresi terakhir yang bertipe ! adalah loop:

fn main() {
    print!("forever ");

    loop {
        print!("and ever ");
    }
}

Di sini, loop tidak pernah berakhir, jadi ! adalah nilai dari ekspresi itu. Akan tetapi, hal itu tidak berlaku jika kita menyertakan break, karena loop akan berhenti saat mencapai break.

Tipe yang Ukurannya Ditentukan Saat Runtime dan Trait Sized

Rust perlu mengetahui detail tertentu tentang tipe-tipenya, seperti berapa banyak ruang yang harus dialokasikan untuk sebuah nilai dari tipe tertentu. Hal ini membuat satu sudut dari sistem tipenya agak membingungkan pada awalnya: konsep tipe yang ukurannya ditentukan saat runtime. Kadang disebut DST atau tipe tanpa ukuran, tipe-tipe ini memungkinkan kita menulis kode dengan nilai yang ukurannya hanya bisa kita ketahui saat runtime.

Mari kita dalami detail dari sebuah tipe yang ukurannya ditentukan saat runtime bernama str, yang sudah kita pakai sepanjang buku ini. Benar, bukan &str, melainkan str sendirian adalah sebuah DST. Dalam banyak kasus, seperti saat menyimpan teks yang dimasukkan pengguna, kita tidak bisa tahu seberapa panjang string itu sampai runtime. Itu berarti kita tidak bisa membuat variabel bertipe str, juga tidak bisa menerima argumen bertipe str. Perhatikan kode berikut, yang tidak bekerja:

fn main() {
    let s1: str = "Hello there!";
    let s2: str = "How's it going?";
}

Rust perlu tahu berapa banyak memori yang harus dialokasikan untuk nilai apa pun dari tipe tertentu, dan semua nilai dari sebuah tipe harus memakai jumlah memori yang sama. Jika Rust mengizinkan kita menulis kode ini, kedua nilai str itu perlu menempati ruang yang sama. Tetapi panjangnya berbeda: s1 butuh 12 byte penyimpanan dan s2 butuh 15. Inilah alasan mengapa tidak mungkin membuat variabel yang menampung tipe yang ukurannya ditentukan saat runtime.

Jadi, apa yang kita lakukan? Dalam hal ini, kamu sudah tahu jawabannya: Kita buat tipe s1 dan s2 menjadi string slice (&str) alih-alih str. Ingat dari bagian “String Slice” di Bab 4 bahwa struktur data slice hanya menyimpan posisi awal dan panjang slice. Jadi, meskipun &T adalah satu nilai yang menyimpan alamat memori tempat T berada, string slice adalah dua nilai: alamat dari str dan panjangnya. Dengan demikian, kita bisa mengetahui ukuran nilai string slice saat compile time: besarnya dua kali panjang usize. Artinya, kita selalu tahu ukuran string slice, tidak peduli seberapa panjang string yang ditunjuknya. Secara umum, beginilah cara tipe yang ukurannya ditentukan saat runtime dipakai di Rust: Mereka punya metadata tambahan yang menyimpan ukuran informasi dinamisnya. Aturan emas tipe yang ukurannya ditentukan saat runtime adalah kita harus selalu menaruh nilainya di belakang semacam pointer.

Kita bisa menggabungkan str dengan berbagai macam pointer: misalnya, Box<str> atau Rc<str>. Faktanya, kamu sudah pernah melihat ini sebelumnya tetapi dengan tipe yang ukurannya ditentukan saat runtime yang berbeda: trait. Setiap trait adalah tipe yang ukurannya ditentukan saat runtime yang bisa kita rujuk dengan memakai nama trait itu. Di bagian “Memakai Trait Object untuk Berabstraksi atas Perilaku Bersama” di Bab 18, kita menyebutkan bahwa untuk memakai trait sebagai trait object, kita harus menaruhnya di belakang pointer, seperti &dyn Trait atau Box<dyn Trait> (Rc<dyn Trait> juga bisa).

Untuk bekerja dengan DST, Rust menyediakan trait Sized guna menentukan apakah ukuran sebuah tipe diketahui saat compile time atau tidak. Trait ini otomatis diimplementasikan untuk apa pun yang ukurannya diketahui saat compile time. Selain itu, Rust secara implisit menambahkan bound Sized pada setiap fungsi generic. Artinya, definisi fungsi generic seperti ini:

fn generic<T>(t: T) {
    // --snip--
}

sebenarnya diperlakukan seolah-olah kita menulis ini:

fn generic<T: Sized>(t: T) {
    // --snip--
}

Secara default, fungsi generic hanya bekerja pada tipe yang ukurannya diketahui saat compile time. Akan tetapi, kamu bisa memakai sintaks khusus berikut untuk melonggarkan pembatasan itu:

fn generic<T: ?Sized>(t: &T) {
    // --snip--
}

Sebuah trait bound pada ?Sized berarti “T boleh Sized atau tidak,” dan notasi ini menggantikan aturan default bahwa tipe generic harus punya ukuran yang diketahui saat compile time. Sintaks ?Trait dengan makna ini hanya tersedia untuk Sized, bukan untuk trait lain.

Perhatikan juga bahwa kita mengganti tipe parameter t dari T menjadi &T. Karena tipe itu mungkin tidak Sized, kita perlu memakainya di belakang semacam pointer. Dalam hal ini, kita memilih reference.

Berikutnya, kita akan membahas fungsi dan closure!