Tipe Data & Koleksi

BAB 15: Tuple

Tuple di Rust mengelompokkan nilai berbeda tipe dengan panjang tetap, dibaca lewat bidang bernomor atau destructuring dan bisa jadi nilai kembalian fungsi.

Fungsi yang perlu mengembalikan 2 hasil sekaligus tidak bisa memakai satu tipe kembalian, dan array tidak menolong karena semua elemennya wajib bertipe sama. Rust menyediakan tuple: nilai gabungan yang menyimpan beberapa nilai berbeda tipe pada posisi bernomor, dengan panjang yang ditetapkan sejak ditulis.

Bab ini membahas cara membuat tuple, membaca bidangnya, membongkarnya dengan pattern, dan memakainya sebagai nilai kembalian fungsi. Setelah bab ini selesai, kamu dapat menulis fungsi yang mengembalikan 2 nilai, memilih antara akses bidang dan destructuring, dan menjelaskan batas panjang tuple. Semua contoh dikompilasi dengan rustc 1.100.0 di mesin ini dan dijalankan dari folder /tmp/latihan-rust/bab15, jadi keluaran yang dikutip berasal dari eksekusi program, bukan dari ingatan.

Mengelompokkan nilai berbeda tipe

Tuple ditulis sebagai daftar nilai yang dipisahkan koma di dalam tanda kurung. Tiap posisi punya tipe sendiri dan tidak harus sama dengan posisi lain. Berkas p1_dasar.rs menyimpan nama, umur, dan nilai seorang siswa dalam satu variabel.

RSRUST
fn main() {
    let siswa = ("Budi", 17, 88.5);

    println!("{:?}", siswa);
    println!("nama {}", siswa.0);
    println!("umur {}", siswa.1);
    println!("nilai {}", siswa.2);
}
CodeTEXT
("Budi", 17, 88.5)
nama Budi
umur 17
nilai 88.5

Satu variabel memegang 3 nilai dengan 3 tipe, yaitu &str, integer, dan float. Macro println! dengan {:?} mencetak seluruh isi tuple di dalam tanda kurung, sedangkan siswa.0 mengambil bidang pertama. Nomor bidang dimulai dari 0, sama seperti indeks array.

Bidang tuple tidak punya nama pilihan penulis. Rust Reference menyatakan bidang tuple dinamai dengan angka yang naik mengikuti posisi, dan bidang pertama bernomor 0. Kode yang membaca siswa.0 bergantung pada urutan penulisan, bukan pada nama yang bermakna.

Anotasi tipe dan tuple bersarang

Anotasi tipe ditulis sebagai daftar tipe berurutan di dalam tanda kurung, dan urutannya harus cocok dengan urutan nilai. Tuple juga boleh berisi tuple lain, dan bidang bertingkat dibaca dengan angka yang dirangkai.

RSRUST
fn main() {
    let titik: (i32, i32) = (3, -4);
    let bersarang = ((1, 2), (3, 4));
    let kosong: () = ();

    println!("titik {:?}", titik);
    println!("x {} y {}", titik.0, titik.1);
    println!("bersarang {:?}", bersarang);
    println!("bersarang.0.1 = {}", bersarang.0.1);
    println!("kosong {:?}", kosong);
    println!("ukuran titik {} byte", std::mem::size_of::<(i32, i32)>());
    println!("ukuran kosong {} byte", std::mem::size_of::<()>());
}
CodeTEXT
titik (3, -4)
x 3 y -4
bersarang ((1, 2), (3, 4))
bersarang.0.1 = 2
kosong ()
ukuran titik 8 byte
ukuran kosong 0 byte

bersarang.0.1 menghasilkan 2, dan bentuk (bersarang.0).1 memberi hasil yang sama. Rangkaian angka dibaca dari kiri ke kanan: bidang 0 menghasilkan tuple (1, 2), lalu bidang 1 dari tuple itu berisi 2.

Ukuran (i32, i32) adalah 8 byte, yaitu jumlah ukuran 2 bidangnya, sementara () berukuran 0 byte. Angka ini dibaca dengan std::mem::size_of, dan dokumentasinya mencantumkan () pada tabel tipe primitif dengan ukuran 0. Menulis anotasi tipe tidak menambah ukuran data, karena anotasi hanya dipakai saat kompilasi.

Destructuring dengan pattern

Destructuring membongkar tuple menjadi variabel terpisah dalam satu baris let. Pattern di sisi kiri harus punya jumlah posisi yang sama dengan tuple, dan posisi yang tidak dipakai ditandai garis bawah.

RSRUST
fn main() {
    let siswa = ("Budi", 17, 88.5);
    let (nama, umur, nilai) = siswa;

    println!("{} berumur {} tahun, nilai {}", nama, umur, nilai);
    println!("tuple asal utuh {:?}", siswa);

    let (_, _, hanya_nilai) = siswa;
    println!("yang diambil {}", hanya_nilai);

    let (x, y);
    (x, y) = (10, 20);
    println!("x {} y {}", x, y);
}
CodeTEXT
Budi berumur 17 tahun, nilai 88.5
tuple asal utuh ("Budi", 17, 88.5)
yang diambil 88.5
x 10 y 20

Baris let (_, _, hanya_nilai) = siswa; mengambil bidang ketiga dan mengabaikan 2 lainnya. Deklarasi tanpa nilai lalu penugasan bertuple juga sah, dan berguna saat nilai baru tersedia beberapa baris setelah deklarasi. Pola ini sering muncul ketika nilai dihitung di dalam blok bersyarat.

Tuple asal masih bisa dibaca setelah destructuring karena 3 bidangnya bertipe &str, i32, dan f64, yang semuanya menyalin dirinya sendiri. Tuple yang memuat String berperilaku berbeda: destructuring memindahkan kepemilikan bidang itu, dan pembacaan tuple asal sesudahnya ditolak.

RSRUST
fn main() {
    let siswa = (String::from("Budi"), 17);
    let (nama, umur) = siswa;

    println!("{} {}", nama, umur);
    println!("{:?}", siswa);
}
CodeTEXT
error[E0382]: borrow of partially moved value: `siswa`
 --> cek_string_move.rs:5:22
  |
3 |     let (nama, umur) = siswa;
  |          ---- value partially moved here
5 |     println!("{:?}", siswa);
  |                      ^^^^^ value borrowed here after partial move
  |
  = note: partial move occurs because `siswa.0` has type `String`, which does not implement the `Copy` trait

Pesan E0382 memakai istilah partial move, yaitu sebagian isi tuple sudah pindah ke variabel lain. Perbaikannya adalah membaca bidang yang masih tersisa, atau meminjam dengan ref seperti yang disarankan kompilator. Aturan kepemilikan sendiri dibahas di bab tentang ownership, jadi untuk sekarang cukup diingat bahwa tuple ikut aturan tipe anggotanya.

Bidang bernomor, bukan nama

Akses bidang hanya menerima angka yang ditulis langsung di kode. Nama variabel tidak bisa menggantikan nomor bidang, dan percobaan itu ditolak kompilator sebelum program berjalan.

RSRUST
fn main() {
    let siswa = ("Budi", 17, 88.5);
    let posisi = 0;

    println!("{}", siswa.posisi);
}
CodeTEXT
error[E0609]: no field `posisi` on type `(&str, {integer}, {float})`
 --> e1_indeks.rs:5:26
  |
5 |     println!("{}", siswa.posisi);
  |                          ^^^^^^ unknown field
  |
  = note: available fields are: `0`, `1`, `2`

error: aborting due to 1 previous error

Pesan E0609 menyebut bidang yang tersedia, yaitu 0, 1, dan 2, sehingga kesalahannya mudah dilacak. Perbaikan yang tepat bergantung pada kebutuhan. Kalau posisinya tetap, tulis siswa.0. Kalau posisi baru diketahui saat berjalan, pilih bidang lewat match pada angka, karena pemilihan bidang tuple ditentukan saat kompilasi, bukan saat program berjalan.

Tuple 1 elemen dan unit type

Tuple 1 elemen butuh koma setelah elemennya. Tanpa koma, tanda kurung hanya mengelompokkan nilai, dan hasilnya bukan tuple.

RSRUST
fn main() {
    let tunggal = (5,);
    let bukan = (5);

    println!("tunggal {:?} isinya {}", tunggal, tunggal.0);
    println!("tanpa koma {:?}", bukan);
    println!("ukuran {} dan {} byte",
        std::mem::size_of::<(i32,)>(),
        std::mem::size_of::<i32>());
}

Kompilator melaporkan peringatan berikut sebelum program dijalankan.

CodeTEXT
warning: unnecessary parentheses around assigned value
 --> p5_satu_elemen.rs:3:17
  |
3 |     let bukan = (5);
  |                 ^ ^
  |
  = note: `#[warn(unused_parens)]` (part of `#[warn(unused)]`) on by default
help: remove these parentheses

Program tetap berjalan dan mencetak hasil berikut.

CodeTEXT
tunggal (5,) isinya 5
tanpa koma 5
ukuran 4 dan 4 byte

size_of::<(i32,)>() dan size_of::<i32>() sama-sama 4 byte, jadi bedanya bukan pada ukuran melainkan pada tipe. Yang pertama adalah tuple berisi 1 bidang, yang kedua integer biasa. Koma pada (5,) adalah penanda tipe, dan karena itu {:?} mencetaknya sebagai (5,), bukan 5.

Tuple tanpa bidang ditulis () dan disebut unit type. Tipe ini punya 1 nilai yang juga ditulis (), dan Rust Reference menyebut nilai unit dipakai saat sebuah ekspresi tidak punya nilai lain yang bermakna. Ukurannya 0 byte, sehingga menyimpannya tidak memakan tempat.

Tuple sebagai nilai kembalian fungsi

Fungsi bisa mengembalikan tuple, dan itu cara paling langsung mengembalikan 2 hasil tanpa membuat struct. Tipe kembalian ditulis sama seperti anotasi tuple, dan nilai akhir fungsi ditulis sebagai tuple juga.

RSRUST
fn bagi(a: i32, b: i32) -> (i32, i32) {
    (a / b, a % b)
}

fn main() {
    let hasil = bagi(17, 5);
    println!("hasil {:?}", hasil);

    let (kuosien, sisa) = bagi(17, 5);
    println!("{} dengan sisa {}", kuosien, sisa);
}
CodeTEXT
hasil (3, 2)
3 dengan sisa 2

bagi(17, 5) mengembalikan (3, 2), yaitu hasil bagi dan sisanya. Pemanggil yang hanya butuh salah satu nilai bisa langsung melakukan destructuring pada hasil pemanggilan, seperti baris kedua. Ini menghindari variabel perantara yang isinya hanya dibaca satu kali.

Fungsi juga boleh menerima tuple sebagai 1 parameter, misalnya fn jarak(titik: (i32, i32)) -> i32. Bedanya dengan 2 parameter terpisah adalah pemanggilnya harus membungkus nilai lebih dulu, dan itu terasa berlebihan kalau nilainya tidak pernah disimpan sebagai tuple.

Mengubah isi tuple

Bidang tuple bisa diubah selama variabelnya dideklarasikan dengan mut. Tanpa mut, penulisan ke satu bidang ditolak dengan kode E0594, bukan E0384, karena yang ditulis adalah bidang, bukan seluruh variabel.

RSRUST
fn main() {
    let titik = (3, -4);
    titik.0 = 10;
    println!("{:?}", titik);
}
CodeTEXT
error[E0594]: cannot assign to `titik.0`, as `titik` is not declared as mutable
 --> e2_ubah.rs:3:5
  |
3 |     titik.0 = 10;
  |     ^^^^^^^^^^^^ cannot assign
  |
help: consider changing this to be mutable
  |
2 |     let mut titik = (3, -4);
  |         +++

error: aborting due to 1 previous error

Kompilator menawarkan perbaikan yang tepat, yaitu menambahkan mut pada deklarasi. Setelah diubah, isi tuple tetap dibaca dengan cara yang sama, dan tipe tiap bidang tidak berubah. Penulisan bidang hanya boleh berisi nilai dengan tipe yang sama, karena tipe tuple ditetapkan sekali saat deklarasi.

Membandingkan tuple

Tuple bisa dibandingkan dengan == dan < selama tipe bidangnya sama. Perbandingan urutan bekerja dari bidang pertama ke bidang berikutnya.

RSRUST
fn main() {
    let a = (1, 5);
    let b = (1, 9);
    let c = (2, 0);

    println!("a < b {}", a < b);
    println!("c > a {}", c > a);
    println!("a == (1, 5) {}", a == (1, 5));

    let mut skor = ("Budi", 70);
    skor.1 = 85;
    println!("setelah diubah {:?}", skor);
}
CodeTEXT
a < b true
c > a true
a == (1, 5) true
setelah diubah ("Budi", 85)

a < b benar karena bidang pertama keduanya sama, yaitu 1, lalu bidang kedua dibandingkan dan 5 lebih kecil dari 9. Dokumentasi std::primitive::tuple menyatakan elemen tuple dibandingkan berurutan sampai ditemukan pasangan yang tidak sama, dan c > a benar karena bidang pertamanya sudah berbeda sehingga bidang kedua tidak perlu dilihat.

Perbandingan antar tuple dengan tipe bidang berbeda ditolak, walaupun angka yang disimpan sama.

RSRUST
fn main() {
    let a = (1i32, 2i32);
    let b = (1u8, 2u8);

    println!("{}", a == b);
}
CodeTEXT
error[E0308]: mismatched types
 --> e3_banding_tipe.rs:5:25
  |
5 |     println!("{}", a == b);
  |                         ^ expected `(i32, i32)`, found `(u8, u8)`
  |
  = note: expected tuple `(i32, i32)`
             found tuple `(u8, u8)`

error: aborting due to 1 previous error

1i32 dan 1u8 menyimpan angka yang sama, tetapi tipenya berbeda, dan Rust tidak menyamakan tipe secara diam-diam di dalam perbandingan. Perbaikannya adalah memilih 1 tipe sejak awal, atau mengubah tipe dengan as sebelum dibandingkan. Literal tanpa akhiran seperti (1, 5) mengikuti tipe pasangannya, jadi kesalahan ini biasanya muncul saat salah satu sisi sudah punya tipe eksplisit.

Batas panjang tuple

Tuple tidak bisa diulang dengan for. Sebuah tuple bukan iterator, dan percobaan memakainya di kepala for berhenti di kompilasi.

RSRUST
fn main() {
    let siswa = ("Budi", 17, 88.5);

    for isi in siswa {
        println!("{}", isi);
    }
}
CodeTEXT
error[E0277]: `(&str, {integer}, {float})` is not an iterator
 --> e4_iterasi.rs:4:16
  |
4 |     for isi in siswa {
  |                ^^^^^ `(&str, {integer}, {float})` is not an iterator
  |
  = help: the trait `Iterator` is not implemented for `(&str, {integer}, {float})`
  = note: required for `(&str, {integer}, {float})` to implement `IntoIterator`

error: aborting due to 1 previous error

Pesan E0277 menyebut trait Iterator, tetapi tuple memang tidak menerapkannya. Untuk data yang perlu diulang, array atau Vec adalah pilihan yang tepat. Tuple juga tidak bisa diindeks dengan rentang, jadi memotong sebagian bidangnya harus ditulis satu per satu.

Batas kedua menyangkut jumlah bidang. Dokumentasi std menyebut Debug, PartialEq, PartialOrd, dan Ord hanya diterapkan pada tuple dengan arity 12 atau kurang. Tuple 13 bidang tetap bisa dibuat dan dibaca bidangnya, tetapi tidak bisa dicetak dengan {:?}.

RSRUST
fn main() {
    let t = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);

    println!("{:?}", t);
}
CodeTEXT
error[E0277]: `({integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer})` doesn't implement `Debug`
 --> e5_arity.rs:4:22
  |
4 |     println!("{:?}", t);
  |               ----   ^ `({integer}, ...)` cannot be formatted using `{:?}` because it doesn't implement `Debug`
  |
  = help: the following other types implement trait `Debug`:
            (T₁, T₂, …, Tₙ) up to tuples of arity 12

Pesan kompilator menyebut batas yang sama, yaitu up to tuples of arity 12. Kalimat di baris ^ dipersingkat dengan elipsis karena tipe yang dicetak panjang, sedangkan baris help dikutip apa adanya. Batas ini yang membuat tuple cocok untuk 2 sampai 4 nilai, bukan untuk data berukuran besar.

Latihan

  1. Buat tuple berisi nama kota, suhu, dan kelembapan, lalu cetak 3 bidangnya dengan {:?} dan dengan akses bidang.
  2. Tulis fungsi min_max yang menerima &[i32] dan mengembalikan tuple (i32, i32) berisi nilai terkecil dan terbesar.
  3. Ubah program e1_indeks.rs supaya memakai match pada variabel posisi untuk memilih bidang 0, 1, atau 2.
  4. Bandingkan 2 tuple siswa dengan < dan jelaskan mengapa hasilnya demikian.

Ringkasan

Tuple mengelompokkan nilai berbeda tipe pada posisi bernomor, dan nomor itu dipakai untuk membaca bidangnya karena tidak ada nama pilihan penulis. Destructuring membongkar tuple menjadi variabel terpisah, dan fungsi bisa mengembalikan tuple saat perlu memberi 2 hasil sekaligus. Batasnya jelas: tuple tidak bisa diulang dengan for, trait seperti Debug hanya berlaku sampai arity 12, dan penulisan bidang menuntut variabel mut.

Referensi

  1. The Rust Programming Language. Data Types.
  2. Rust Standard Library. Primitive Type tuple.
  3. The Rust Reference. Tuple types.
  4. Rust Standard Library. std::mem::size_of.