Module System

BAB 27: Type Alias & Casting

Type alias memberi nama pendek pada tipe panjang tanpa membuat tipe baru, sedangkan as mengubah nilai numerik secara eksplisit dan bisa memotong angkanya.

Result<Vec<String>, String> adalah tipe yang sah, tetapi menuliskannya berkali-kali di signature fungsi membuat kode sulit dibaca. Rust menyediakan type untuk memberi nama pada tipe yang sudah ada, dan as untuk mengubah nilai dari 1 tipe numerik ke tipe numerik lain secara eksplisit. Keduanya sama-sama terlihat seperti konversi, padahal batas kemampuannya berbeda jauh.

Reference Rust menuliskan definisi type alias dalam 1 kalimat: "A type alias defines a new name for an existing type in the type namespace of the module or block where it is located." Kalimat itu memuat 2 hal yang sering terlewat, yaitu alias hanya nama dan bukan tipe baru, serta alias hidup di type namespace sehingga bisa bertabrakan dengan nama tipe lain di modul yang sama.

Setelah bab ini selesai, kamu dapat memendekkan tipe panjang dengan type, menjelaskan kenapa alias tidak mencegah tertukarnya satuan, memakai as untuk konversi numerik beserta akibat pemotongan bit dan saturasi, serta memilih try_from ketika nilai harus diperiksa lebih dulu. Semua contoh dikompilasi dengan rustc --edition 2021 versi 1.100.0 pada folder /tmp/latihan-rust/bab27.

Alias memberi nama pada tipe yang panjang

Alias dideklarasikan dengan kata kunci type, lalu nama baru, tanda =, lalu tipe aslinya. Nama itu bisa langsung dipakai di posisi tipe mana pun.

RSRUST
type Hasil = Result<Vec<String>, String>;
type DaftarNama = Vec<String>;

fn muat() -> Hasil {
    Ok(vec![String::from("ani"), String::from("budi")])
}

fn main() {
    let nama: DaftarNama = muat().unwrap();

    println!("jumlah: {}", nama.len());
    println!("isi: {:?}", nama);
    println!("Hasil: {} byte", std::mem::size_of::<Hasil>());
    println!("Result: {} byte", std::mem::size_of::<Result<Vec<String>, String>>());
}
CodeTEXT
jumlah: 2
isi: ["ani", "budi"]
Hasil: 32 byte
Result: 32 byte

Fungsi muat mengembalikan Hasil, dan pemanggilnya menerima DaftarNama dari unwrap(). Kedua nama itu tidak menambah lapisan apa pun: hasil size_of menunjukkan Hasil dan tipe aslinya sama-sama 32 byte. Alias hanya dipakai kompilator untuk membaca kode, lalu dibuang dari hasil kompilasi.

Alias juga bisa menutupi tipe generik yang sudah dipenuhi parameter konkretnya. Contoh berikut memberi nama pada HashMap<String, Vec<u8>> supaya signature fungsi tidak dipenuhi tanda kurung siku.

RSRUST
type Peta = std::collections::HashMap<String, Vec<u8>>;

fn ringkas(peta: &Peta) -> usize {
    peta.values().map(|v| v.len()).sum()
}

fn main() {
    let mut peta: Peta = Peta::new();
    peta.insert(String::from("a"), vec![1, 2, 3]);
    peta.insert(String::from("b"), vec![4, 5]);

    println!("kunci: {}", peta.len());
    println!("total: {}", ringkas(&peta));
}
CodeTEXT
kunci: 2
total: 5

Perhatikan bahwa Peta::new() tetap bisa dipanggil lewat nama alias, karena alias dan tipe aslinya menunjuk ke tipe yang sama. Reference Rust mencatat 1 pengecualian: alias ke tuple struct tidak bisa dipakai memanggil konstruktornya. Untuk struct Titik(i32, i32), nama Titik tetap harus ditulis saat membuat nilai, sedangkan alias hanya berguna di posisi tipe.

Alias tidak membuat tipe baru

Karena alias hanya nama lain, kompilator menganggap 2 alias dari tipe yang sama sebagai tipe yang identik. Akibatnya alias tidak bisa dipakai menandai satuan.

RSRUST
type Kilometer = f64;
type Mil = f64;

fn ke_kilometer_asli(mil: Mil) -> Kilometer {
    mil * 1.609344
}

fn main() {
    let jarak: Mil = 10.0;
    let tertukar: Kilometer = jarak;

    println!("{}", tertukar);
    println!("{}", ke_kilometer_asli(10.0));
}
CodeTEXT
10
16.09344

Program di atas lolos kompilasi tanpa 1 peringatan, padahal baris let tertukar: Kilometer = jarak; memindahkan nilai bermakna mil ke variabel bermakna kilometer. Keduanya f64, jadi tidak ada yang bisa diperiksa. Baris kedua menunjukkan masalah yang sama dari arah sebaliknya: ke_kilometer_asli(10.0) menerima angka tanpa satuan, karena parameter Mil sebenarnya hanya f64.

Kesalahan seperti ini tidak muncul saat kompilasi dan baru terlihat saat angkanya sudah salah. Kalau satuan perlu dijaga oleh tipe, alias bukan alat yang tepat.

Newtype menutup celah satuan

Tipe baru yang membungkus 1 nilai, atau newtype, memaksa pemanggil menyebut satuannya. Struct 1 field tanpa pub juga menyembunyikan isinya dari modul lain, dan aturan itu dibahas di bab berikutnya.

RSRUST
struct Kilometer(f64);
struct Mil(f64);

fn ke_kilometer(mil: Mil) -> Kilometer {
    Kilometer(mil.0 * 1.609344)
}

fn main() {
    let jarak = ke_kilometer(Mil(10.0));
    println!("{:.4} km", jarak.0);
}
CodeTEXT
16.0934 km

Sekarang let tertukar: Kilometer = Mil(10.0); akan ditolak dengan E0308, karena Mil dan Kilometer adalah 2 tipe berbeda. Harganya adalah 2 baris deklarasi dan 1 lapisan .0 saat membaca nilai. Untuk kode yang menghitung uang, waktu, atau jarak, harga itu sepadan.

Alias untuk tipe fungsi

Tipe fungsi juga bisa diberi alias. Bentuk fn(i32, i32) -> i32 adalah tipe pointer fungsi, yaitu alamat kode yang bisa disimpan di variabel dan dipanggil.

RSRUST
type Operasi = fn(i32, i32) -> i32;

fn tambah(a: i32, b: i32) -> i32 {
    a + b
}

fn kali(a: i32, b: i32) -> i32 {
    a * b
}

fn main() {
    let daftar: [(&str, Operasi); 2] = [("tambah", tambah), ("kali", kali)];

    for (nama, op) in daftar {
        println!("{}: {}", nama, op(6, 7));
    }

    let op: Operasi = tambah;
    println!("lewat variabel: {}", op(1, 1));
}
CodeTEXT
tambah: 13
kali: 42
lewat variabel: 2

Tipe [(&str, Operasi); 2] menyatakan array berisi 2 pasang nama dan fungsi. Tanpa alias, tipe itu ditulis [(&str, fn(i32, i32) -> i32); 2], dan bentuk panjang itu harus diulang di setiap signature yang menerimanya. Alias di sini tidak mengubah perilaku apa pun, hanya memindahkan tipe yang berulang ke 1 tempat.

Cast numerik dengan as

Operator as meminta konversi tipe secara eksplisit. Rust tidak melakukan konversi numerik implisit, jadi penulisan as adalah satu-satunya jalan pintas untuk berpindah tipe angka.

RSRUST
fn main() {
    let a: i32 = 300;
    println!("300 as u8 = {}", a as u8);

    let negatif: i32 = -1;
    println!("-1 as u8 = {}", negatif as u8);

    let desimal: f64 = 3.99;
    println!("3.99 as i32 = {}", desimal as i32);

    let kecil: i32 = 7;
    println!("7 as f64 = {}", kecil as f64);
    println!("7 as f32 / 2.0 = {}", kecil as f32 / 2.0);

    let huruf: u8 = b'A';
    println!("b'A' as char = {}", huruf as char);
}
CodeTEXT
300 as u8 = 44
-1 as u8 = 255
3.99 as i32 = 3
7 as f64 = 7
7 as f32 / 2.0 = 3.5
b'A' as char = A

300 as u8 menghasilkan 44 karena u8 hanya menyimpan 8 bit. Angka 300 ditulis dalam biner sebagai 1 0010 1100, dan 8 bit terakhirnya adalah 0010 1100, yaitu 44. Tidak ada peringatan dan tidak ada panic: as memotong bit yang tidak muat. Hal yang sama terjadi pada -1 as u8, yang menghasilkan 255 karena representasi two's complement dari -1 adalah 8 bit bernilai 1 semua.

Konversi ke char hanya berlaku dari u8, dan Reference Rust menyebutnya "Casts to the char with the corresponding code point". Karena u8 hanya menjangkau 0 sampai 255, cast ini tidak bisa menghasilkan karakter di luar Latin-1. Untuk teks di luar rentang itu, char::from_u32 yang mengembalikan Option<char> dipakai, dan hasilnya dibahas pada bab tentang Option.

Cast float ke integer

Konversi dari float ke integer punya 3 perilaku yang perlu dihafal, dan semuanya bisa dibuktikan dengan 1 program.

RSRUST
fn main() {
    let besar: f64 = 1e20;
    println!("1e20 as i32 = {}", besar as i32);
    println!("i32::MAX = {}", i32::MAX);

    let nan: f64 = f64::NAN;
    println!("NAN as i32 = {}", nan as i32);

    let negatif: f64 = -1.9;
    println!("-1.9 as i32 = {}", negatif as i32);

    let panjang: u64 = 18_446_744_073_709_551_615;
    println!("u64 max as i32 = {}", panjang as i32);
}
CodeTEXT
1e20 as i32 = 2147483647
i32::MAX = 2147483647
NAN as i32 = 0
-1.9 as i32 = -1
u64 max as i32 = -1

Reference Rust menjelaskan ketiga perilaku itu: cast dari float ke integer membulatkan ke arah nol, NaN menghasilkan 0, dan nilai di luar batas menempel ke batas tipe tujuannya. Itulah yang terlihat pada 1e20, yang tidak muat di i32 lalu menjadi i32::MAX, dan pada -1.9 yang menjadi -1, bukan -2.

Perilaku menempel ke batas ini berlaku sejak Rust 1.45. Rust by Example mencatat perubahan itu dengan kalimat "Since Rust 1.45, the as keyword performs a saturating cast when casting from float to int". Sebelum versi tersebut, hasilnya tidak didefinisikan untuk nilai di luar batas.

Baris terakhir menunjukkan aturan berbeda untuk sesama integer: u64 maksimum yang di-cast ke i32 menghasilkan -1, karena 64 bit dipotong menjadi 32 bit bawah dan semuanya bernilai 1. Saturasi hanya berlaku pada jalur float ke integer, sedangkan integer ke integer tetap memotong bit.

Cast yang ditolak kompilator

as bukan konversi serbaguna. Operator itu hanya menerima tipe primitif, sehingga String tidak bisa diubah menjadi angka dengan as.

RSRUST
fn main() {
    let teks = String::from("42");
    let angka = teks as i32;
    println!("{}", angka);
}
CodeTEXT
error[E0605]: non-primitive cast: `String` as `i32`
 --> salah_cast.rs:3:17
  |
3 |     let angka = teks as i32;
  |                 ^^^^^^^^^^^ an `as` expression can only be used to convert between primitive types or to coerce to a specific trait object

error: aborting due to 1 previous error

Pesan itu menyebut batasnya dengan jelas: as hanya untuk primitif. Perbaikan yang benar bergantung pada maksud kode. Kalau teksnya memang berisi angka, teks.parse::<i32>() dipakai dan hasilnya Result. Kalau konversinya antar tipe angka, as boleh dipakai.

Enum juga terkena batas yang sama, dengan syarat tambahan. Cast enum ke angka hanya sah untuk enum yang semua variannya tanpa data.

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

fn main() {
    let b = Bentuk::Persegi(2.0);
    println!("{}", b as i32);
}
CodeTEXT
error[E0605]: non-primitive cast: `Bentuk` as `i32`
 --> salah_cast_enum.rs:8:20
  |
8 |     println!("{}", b as i32);
  |                    ^^^^^^^^ an `as` expression can be used to convert enum types to numeric types only if the enum type is unit-only or field-less

error: aborting due to 1 previous error

Komentar kompilator menjelaskan sebabnya: tidak ada 1 angka yang mewakili seluruh isi varian Persegi, karena varian itu membawa f64. Untuk enum berdata, isinya diambil lewat match. Untuk enum tanpa data, cast ke angka tetap sah dan sudah dipakai pada bab tentang enum.

Alias tetap diperiksa tipenya

Alias tidak menghilangkan pemeriksaan tipe. Nilai yang salah tetap ditolak, dan pesan errornya menyebut tipe asli, bukan nama alias.

RSRUST
type Hasil = Result<i32, String>;

fn main() {
    let nilai: Hasil = 42;
    println!("{:?}", nilai);
}
CodeTEXT
error[E0308]: mismatched types
 --> salah_alias.rs:4:24
  |
4 |     let nilai: Hasil = 42;
  |                -----   ^^ expected `Result<i32, String>`, found integer
  |                |
  |                expected due to this
  |
  = note: expected enum `Result<i32, String>`
             found type `{integer}`
help: try wrapping the expression in `Ok`
  |
4 |     let nilai: Hasil = Ok(42);
  |                        +++  +

error: aborting due to 1 previous error

Kompilator menulis expected enum Result<i32, String> walaupun kode menulis Hasil. Alias diperluas lebih dulu, lalu pemeriksaan tipe berjalan pada tipe hasil perluasan. Karena itu pesan error selalu bisa dibaca tanpa harus membuka deklarasi alias di bagian atas berkas.

Konversi yang memeriksa nilai

as tidak pernah gagal, dan itu sumber masalah pada data dari luar program. TryFrom mengembalikan Result, sehingga nilai yang tidak muat bisa ditangani sebelum dipakai.

RSRUST
fn main() {
    let besar: i32 = 300;
    match u8::try_from(besar) {
        Ok(nilai) => println!("aman: {}", nilai),
        Err(pesan) => println!("gagal: {}", pesan),
    }

    let kecil: i32 = 42;
    println!("{:?}", u8::try_from(kecil));
}
CodeTEXT
gagal: number too large to fit in target type
Ok(42)

Bedanya jelas: 300 as u8 menghasilkan 44 tanpa keluhan, sedangkan u8::try_from(300) mengembalikan Err yang bisa dilaporkan ke pengguna. Pilih as kalau pemotongan bit memang yang diinginkan, misalnya saat mengambil byte rendah dari sebuah kode, dan pilih try_from kalau angka datang dari input berkas, jaringan, atau argumen program.

TryFrom sudah ada di prelude sejak edition 2021, jadi use std::convert::TryFrom; tidak perlu ditulis lagi. Pada edition 2015 dan 2018, baris use itu masih dibutuhkan.

Latihan

  1. Buat type Suhu = f64; dan fungsi ke_fahrenheit(celsius: Suhu) -> Suhu. Setelah itu ubah aliasnya menjadi struct Suhu(f64) dan catat error yang muncul pada pemanggilan lama.
  2. Jalankan let x: u8 = 200; println!("{}", x as i8); lalu jelaskan kenapa hasilnya negatif dengan memakai representasi 8 bit.
  3. Ubah salah_cast.rs supaya berhasil dengan parse::<i32>(), dan tangani Result yang dikembalikan tanpa unwrap.
  4. Buat type Matriks = Vec<Vec<f64>>; beserta fungsi jumlah_baris(&Matriks, usize) -> f64, lalu panggil dengan matriks 3 baris.

Ringkasan

Type alias memberi nama pada tipe yang sudah ada, dan hasil size_of di bab ini menunjukkan alias tidak menambah ukuran maupun membuat tipe baru. Karena itu alias tidak bisa dipakai menjaga satuan, dan newtype dengan struct 1 field dipakai saat tipe memang perlu dibedakan. Operator as mengubah tipe primitif secara eksplisit, dengan 3 perilaku yang diukur di sini: pemotongan bit pada sesama integer, pembulatan ke arah nol pada float ke integer, serta saturasi di batas tipe dan hasil 0 untuk NaN. Cast yang tidak sah, misalnya String atau enum berdata ke i32, ditolak sebagai E0605, sedangkan nilai yang tipenya tidak cocok tetap ditolak sebagai E0308 walaupun namanya ditulis lewat alias.

Referensi

  1. The Rust Reference. Type aliases.
  2. The Rust Reference. Type cast expressions.
  3. Rust By Example. Casting.