Tuples

Tuple di Rust menggunakan (). Kita sudah sering melihat tuple yang kosong, karena parameter kosong pada function sebenarnya adalah sebuah tuple kosong:

fn do_something() {}

sebenarnya adalah kependekan dari:

fn do_something() -> () {}

Function tidak menerima apapun (tuple kosong), dan tidak mengembalikan apapun juga (tuple kosong). Sehingga kita sebenarnya sudah berkali-kali menggunakan tuple di tutorial ini. Jika Anda tidak me-return apapun pada function, maka sebenarnya Anda me-return tuple kosong.

fn just_prints() {
    println!("I am printing"); // Menambahkan ; berarti kita me-return sebuah tuple kosong
}

fn main() {}

Tuples bisa menyimpan banyak data, dan bisa menyimpan type yang berbeda pula. Item-item di dalam tuple juga di-index menggunakan angka 0, 1, 2, dan seterusnya. Untuk mengakses index pada array, kita menggunakan [], sedangkan pada vector kita menggunakan .. Mari kita coba untuk memasukkan bermacam-macam type ke dalam sebuah tuple.

fn main() {
    let random_tuple = ("Here is a name", 8, vec!['a'], 'b', [8, 9, 10], 7.7);
    println!(
        "Inside the tuple is: First item: {:?}
Second item: {:?}
Third item: {:?}
Fourth item: {:?}
Fifth item: {:?}
Sixth item: {:?}",
        random_tuple.0,
        random_tuple.1,
        random_tuple.2,
        random_tuple.3,
        random_tuple.4,
        random_tuple.5,
    )
}

Hasil printnya adalah:

Inside the tuple is: First item: "Here is a name"
Second item: 8
Third item: ['a']
Fourth item: 'b'
Fifth item: [8, 9, 10]
Sixth item: 7.7

Type dari tuple di atas adalah (&str, i32, Vec<char>, char, [i32; 3], f64).

Anda bisa menggunakan tuple untuk membuat banyak variabel. Kita lihat code berikut ini:

fn main() {
    let str_vec = vec!["one", "two", "three"];
}

str_vec memiliki 3 item di dalamnya. Bagaimana jika kita ingin menarik mereka keluar? Inilah dimana kita bisa menggunakan tuple.

fn main() {
    let str_vec = vec!["one", "two", "three"];

    let (a, b, c) = (str_vec[0], str_vec[1], str_vec[2]); // memberi mereka nama sebagai a, b, dan c
    println!("{:?}", b);
}

Hasil printnya adalah "two", yang mana itu adalah isi dari variabel b. Cara seperti ini biasa dinamakan sebagai destructuring. Karena variabel awalnya berada di dalam struktur, namun di saat kita memecahnya menjadi variabel a, b, dan c, variabel-variabel tersebut tidak lagi ada di dalam struktur tersebut.

Jika Anda perlu melakukan destructure tapi tidak menginginkan semua variabelnya, Anda bisa menggunakan _.

fn main() {
    let str_vec = vec!["one", "two", "three"];

    let (_, _, apple) = (str_vec[0], str_vec[1], str_vec[2]);
}

Pada code di atas, ia hanya membuat sebuah variabel bernama apple, tapi tidak membuat variabel untuk yang lainnya.

Masih ada banyak lagi type collection, dan masih banyak lagi cara untuk menggunakan array, vec, dan tuple. Kita juga akan mempelajari lebih lanjut tentang mereka semua, akan tetapi, pertama-tama kita belajar terlebih dahulu tentang control flow.