Tuple

Posted on 2026年7月4日 by
  1. Sintaks instansiasi tuple struct: NamaStruktur(nilai1, nilai2, ...) ;
  2. Dengan tambahan #[derive(Debug)], struktur mendukung cetak debug lewat {:?}.

    3. Tuple adalah koleksi yang digunakan untuk menyimpan nilai dari berbagai tipe yang berbeda. Tuple dibuat menggunakan tanda kurung bulat (). Setiap tuple sendiri merupakan nilai mandiri, penulisan tipenya adalah (T1, T2, ...), di mana T1 dan T2 melambangkan tiap tipe anggota di dalam tuple. Fungsi dapat mengembalikan beberapa hasil dengan bantuan tuple, karena satu tuple dapat menampung data dengan jumlah berapapun.

    1 Menggunakan tuple sebagai parameter dan nilai kembalian fungsi

    // Tuple bisa dipakai sebagai parameter masukan sekaligus nilai yang dikembalikan fungsi
fn reverse(pair: (i32, bool)) -> (bool, i32) {
    // Kata kunci let bisa mendekonstruksi anggota tuple lalu mengikatnya ke variabel terpisah
    let (int_param, bool_param) = pair;
    // Mengembalikan tuple baru dengan urutan elemen yang dibalik
    (bool_param, int_param)
}

fn main(){
    // (12, true) adalah tuple dua elemen lengkap, dikirim sebagai satu parameter tunggal
	let res = reverse((12, true));
	// Pakai indeks .0 untuk mengambil elemen pertama dari tuple hasil kembalian
	println!("{}", res.0);
}

    Hasil kompilasi dan eksekusi

    E:\rustdemo\demo>rustc demo.rs

E:\rustdemo\demo>demo
true

    2 Definisi Tuple Struct (Struktur Tuple)

    #[derive(Debug)]
struct Matrix(f32, f32, f32, f32);

fn main(){
    let matrix = Matrix(1.1, 1.2, 2.1, 2.2);
    println!("{:?}", matrix);
}

    Struktur tipe tuple: nama struktur langsung diikuti kurung bulat beserta daftar tipe, tidak ada field bernama, elemen hanya dibedakan berdasarkan urutan;

    Makro turunan #[derive(Debug)]: secara otomatis mengimplementasikan trait Debug pada struktur, sehingga bisa mencetak informasi debug dengan {:?};

    Matrix(f32,f32,f32,f32) pada dasarnya adalah tuple khusus yang membungkus empat bilangan titik mengambang.

    Akan muncul peringatan saat program dijalankan, Anda bisa mengabaikannya

    E:\rustdemo\demo>rustc demo.rs
warning: fields `0`, `1`, `2`, and `3` are never read
 --> demo.rs:2:15
  |
2 | struct Matrix(f32, f32, f32, f32);
  |        ------ ^^^  ^^^  ^^^  ^^^
  |        |
  |        fields in this struct
  |
  = help: consider removing these fields
  = note: `Matrix` has a derived impl for the trait `Debug`, but this is intentionally ignored during dead code analysis
  = note: `#[warn(dead_code)]` (part of `#[warn(unused)]`) on by default

warning: 1 warning emitted


E:\rustdemo\demo>demo
Matrix(1.1, 1.2, 2.1, 2.2)

    3 Tuple panjang dengan tipe campuran + mengambil nilai lewat indeks

    Lihat contoh terlebih dahulu

    fn main(){

    // Tuple panjang yang berisi berbagai tipe data berbeda
    let long_tuple = (1u8, 2u16, 3u32, 4u64,
                      -1i8, -2i16, -3i32, -4i64,
                      0.1f32, 0.2f64,
                      'a', true);

    // Nilai di dalam tuple bisa diambil menggunakan indeks tuple
    println!("Long tuple first value: {}", long_tuple.0);
    println!("Long tuple second value: {}", long_tuple.1);
}

    Bisa menyimpan data tipe berbeda secara bersamaan (bilangan bulat tanpa tanda, bilangan bulat bertanda, bilangan titik mengambang, karakter dan boolean bisa ada bersama) ;

    Sintaks indeks tuple: variabel_tuple.angka, indeks dimulai dari angka 0 ;

    • .0 untuk ambil elemen pertama,
    • .1 untuk ambil elemen kedua ;
    • dan seterusnya…

    Indeks hanya boleh berupa literal angka tetap, variabel tidak bisa dipakai sebagai indeks.

    Bagian yang belum dirapikan ada di bawah——

    2. Definisi Tuple Struct (Struktur Tuple)

    
// Struktur di bawah untuk latihan setelah kelas
#[derive(Debug)]
struct Matrix(f32, f32, f32, f32);

    Poin pengetahuan terkait

    1. Struktur tipe tuple: nama struktur diikuti kurung bulat dengan daftar tipe di dalamnya. Tidak ada nama field, elemen hanya dibedakan berdasarkan urutan ;
    2. Makro turunan #[derive(Debug)]: secara otomatis mengimplementasikan trait Debug pada struktur, mendukung cetak debug pakai {:?} ;
    3. Matrix(f32,f32,f32,f32) pada dasarnya adalah tuple khusus yang membungkus empat bilangan titik mengambang.

    Contoh lengkap ada di bawah

    #[derive(Debug)]
struct Matrix(f32, f32, f32, f32);

fn main() {
    // 1. Membuat instansi
    let mat = Matrix(1.0, 2.0, 3.0, 4.0);

    // 2. Mencetak (perlu #[derive(Debug)] agar bisa pakai {:?})
    println!("Instansi matriks: {:?}", mat);

    // 3. Akses elemen dalam lewat .indeks
    let a = mat.0;
    let b = mat.1;
    let c = mat.2;
    let d = mat.3;
    println!("a={}, b={}, c={}, d={}", a, b, c, d);

    // 4. Ambil nilai dengan dekonstruksi
	// Matrix(m0, m1, m2, m3) adalah pola pencocokan dekonstruksi. m0/m1/m2/m3 adalah nama variabel sementara buatan sendiri yang menerima nilai empat anggota tuple di dalam struktur.
    let Matrix(m0, m1, m2, m3) = mat;
    println!("Dekonstruksi：{} {} | {} {}", m0, m1, m2, m3);
	

    // 5. Matriks mutable, ubah elemen pakai mut
    let mut mat_mut = Matrix(0.0, 0.0, 0.0, 0.0);
    mat_mut.0 = 10.0;
    mat_mut.3 = 99.0; // Nilai bisa diubah
    println!("Matriks mutable: {:?}", mat_mut);
}

    Hasil eksekusi

    E:\rustdemo\demo>demo
Instansi matriks: Matrix(1.0, 2.0, 3.0, 4.0)
a=1, b=2, c=3, d=4
Dekonstruksi：1 2 | 3 4
Matriks mutable: Matrix(10.0, 0.0, 0.0, 99.0)

    3 Tuple panjang dengan tipe campuran + mengambil nilai lewat indeks

    fn main() {
 
    // Tuple panjang yang berisi berbagai tipe data berbeda
    let long_tuple = (1u8, 2u16, 3u32, 4u64,
                      -1i8, -2i16, -3i32, -4i64,
                      0.1f32, 0.2f64,
                      'a', true);

    // Values can be extracted from the tuple using tuple indexing.
    // Nilai di dalam tuple bisa diambil menggunakan indeks tuple
    println!("Long tuple first value: {}", long_tuple.0);
    println!("Long tuple second value: {}", long_tuple.1);
}

    Hasil eksekusi

    E:\rustdemo\demo>demo
Long tuple first value: 1
Long tuple second value: 2

    Ringkasan

    1. Ciri utama tuple: bisa menyimpan data tipe berbeda secara bersamaan (bilangan bulat tanpa tanda, bilangan bulat bertanda, bilangan titik mengambang, karakter dan boolean bisa ada bersama) ;
    2. Sintaks indeks tuple: variabel_tuple.angka, indeks dimulai dari angka 0 ;
      • .0 untuk ambil elemen pertama,
      • .1 untuk ambil elemen kedua ;
    3. Indeks hanya boleh berupa literal angka tetap, variabel tidak bisa dipakai sebagai indeks.

    4 Tuple bersarang

    fn main() {
 
    // Anggota tuple sendiri bisa berupa tuple, mendukung penyusunan bersarang
    let tuple_of_tuples = ((1u8, 2u16, 2u32), (4u64, -1i8), -2i16);

 
    // Tuple mendukung cetak debug
    println!("tuple of tuples: {:?}", tuple_of_tuples);
	
	// Pakai dua titik beruntun untuk cetak nilai
	println!("tuple of tuples: {:?}", tuple_of_tuples.0.1); // Keluar angka 2
}

    Hasil keluaran

    E:\rustdemo\demo>demo
tuple of tuples: ((1, 2, 2), (4, -1), -2)
tuple of tuples: 2

    Ringkasan

    1. Mendukung tuple bersarang berlapis banyak, elemen tuple luar bisa berupa sub-tuple ;
    2. Tuple dengan elemen ≤12 akan otomatis mengimplementasikan trait Debug, penentu format {:?} bisa cetak seluruh isi secara langsung.

    5 Batas cetak tuple terlalu panjang (error kompilasi)

    
   fn main() {
 
    // Tuple dengan elemen lebih dari 12 tidak bisa dicetak langsung pakai Debug
    let too_long_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);
    println!("Too long tuple: {:?}", too_long_tuple);
    // Petunjuk: hapus komentar dua baris di atas untuk lihat error kompiler
}

    Pesan error kompilasi

    E:\rustdemo\demo>rustc demo.rs
error[E0277]: `({integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer})` doesn't implement `Debug`
 --> demo.rs:5:38
  |
5 |     println!("Too long tuple: {:?}", too_long_tuple);
  |                               ----   ^^^^^^^^^^^^^^ `({integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer})` cannot be formatted using `{:?}` because it doesn't implement `Debug`
  |                               |
  |                               required by this formatting parameter
  |
  = help: the trait `Debug` is not implemented for `({integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer}, {integer})`
  = help: the following other types implement trait `Debug`:
            ()
            (A, Z, Y, X, W, V, U, T)
            (B, A, Z, Y, X, W, V, U, T)
            (C, B, A, Z, Y, X, W, V, U, T)
            (D, C, B, A, Z, Y, X, W, V, U, T)
            (E, D, C, B, A, Z, Y, X, W, V, U, T)
            (T,)
            (U, T)
          and 5 others
  = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)

error: aborting due to 1 previous error

For more information about this error, try `rustc --explain E0277`.

    Ringkasan

    Pustaka standar Rust hanya menghasilkan trait Debug secara otomatis untuk tuple dengan 0–12 elemen ;

    Tuple dengan elemen lebih dari 12 tidak punya implementasi bawaan Debug, cetak langsung pakai {:?} akan menyebabkan kompilasi gagal.

    Anda bisa hapus angka 13 di atas lalu tes untuk cek apakah error hilang

    6 Panggil fungsi parameter tuple, lihat hasil yang sudah dibalik

    // Tuple bisa dipakai sebagai parameter masukan sekaligus nilai yang dikembalikan fungsi
fn reverse(pair: (i32, bool)) -> (bool, i32) {
    // Kata kunci let bisa mendekonstruksi anggota tuple lalu mengikatnya ke variabel terpisah
    let (int_param, bool_param) = pair;
    // Mengembalikan tuple baru dengan urutan elemen yang dibalik
    (bool_param, int_param)
}

fn main() {
 
    let pair = (1, true);
    println!("Pair is {:?}", pair);

    println!("The reversed pair is {:?}", reverse(pair)); // Panggil reverse untuk balik urutan
}

    Hasil eksekusi

    E:\rustdemo\demo>demo
Pair is (1, true)
The reversed pair is (true, 1)

    Ringkasan

    1. Tuple dua elemen biasa bisa langsung dikirim sebagai argumen ke fungsi yang menerima tuple ;
    2. Fungsi akan mengembalikan tuple baru sepenuhnya, tuple asli pair tidak berubah.

    7 Aturan khusus koma untuk tuple satu elemen (titik sering salah)

    
   fn main() {
 
    // Saat membuat tuple satu elemen wajib tambah koma, agar beda dengan literal biasa hanya dibungkus kurung
    println!("One element tuple: {:?}", (5u32,)); 
    println!("Just an integer: {:?}", (5u32));

}

    Ringkasan

    1. (5u32,): ada koma di akhir, ini adalah tuple satu elemen valid, tipe (u32,) ;
    2. (5u32): tanpa koma, hanya sama dengan angka biasa 5u32 yang dibungkus kurung, bukan tuple ;
    3. Koma adalah satu-satunya penanda yang membedakan tuple satu elemen dengan ekspresi dalam kurung.

    8 Dekonstruksi penuh tuple banyak elemen (lihat di atas)

    
    // Tuple bisa didekonstruksi penuh untuk mengikat beberapa variabel sekaligus
    let tuple = (1, "hello", 4.5, true);

    let (a, b, c, d) = tuple;
    println!("{:?}, {:?}, {:?}, {:?}", a, b, c, d);

    Ringkasan

    1. Tuple panjang berapapun bisa didekonstruksi penuh, jumlah variabel di sebelah kiri harus sama persis dengan jumlah elemen tuple ;
    2. Setelah dekonstruksi tiap variabel cocok dengan nilai posisi yang sama di tuple dan bisa dipakai terpisah.

    9 Instansiasi tuple struct dan cetak Debug

    #[derive(Debug)]
struct Matrix(f32, f32, f32, f32);

fn main() {
 
    let matrix = Matrix(1.1, 1.2, 2.1, 2.2);
    println!("{:?}", matrix);

}

    Ringkasan

    1. Sintaks instansiasi tuple struct: NamaStruktur(nilai1, nilai2, ...) ;
    2. Dengan tambahan #[derive(Debug)], struktur mendukung cetak debug lewat {:?}.
POSTED IN Rust Panduan

Tinggalkan Balasan

Alamat email Anda tidak akan dipublikasikan. Ruas yang wajib ditandai *