🦀 Rust – Tuples: Group Multiple Values with Fixed Structure

Introduction – Why Learn Tuples in Rust?

Tuples in Rust are lightweight, fixed-size collections that can hold multiple values of different types. They’re perfect for returning multiple values, packing/unpacking data, and function inputs/outputs where structure matters but naming is optional.

In this guide, you’ll learn:

• How to declare, access, and destructure tuples
• How tuples differ from arrays and structs
• Common use cases like function returns
• Full examples with output and explanations

Creating a Tuple

Code Example:

fn main() {
    let person = ("Alice", 30, 5.6);
    println!("Name: {}, Age: {}, Height: {}", person.0, person.1, person.2);
}

Explanation:

• Tuples can hold different data types (&str, i32, f64)
• Access elements using .0, .1, .2, etc.

Output:

Name: Alice, Age: 30, Height: 5.6

Destructuring Tuples

Code Example:

fn main() {
    let coords = (10, 20);
    let (x, y) = coords;

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

Explanation:

• Destructuring allows unpacking tuple into individual variables
• Useful for function returns and clean code

Output:

x = 10, y = 20

Returning Multiple Values from a Function

Code Example:

fn calculate(x: i32, y: i32) -> (i32, i32) {
    (x + y, x * y)
}

fn main() {
    let (sum, product) = calculate(4, 5);
    println!("Sum = {}, Product = {}", sum, product);
}

Explanation:

• Function returns a tuple of two i32 values
• Destructuring allows capturing both return values directly

Output:

Sum = 9, Product = 20

Tuple Types and Length

Code Example:

fn main() {
    let t1: (i32, f64, char) = (42, 3.14, 'R');
    println!("{:?}", t1);
}

Explanation:

• You can specify tuple type explicitly: (i32, f64, char)
• Tuple length is fixed; you can’t grow or shrink it

Output:

(42, 3.14, 'R')

Tuple vs Array vs Struct

Common Tuple Mistakes

Summary – Recap & Next Steps

Tuples in Rust are a simple yet powerful way to group related values, especially for function arguments or multiple return values. With indexed access and destructuring, they’re a convenient tool in every Rustacean’s toolkit.

Key Takeaways:

• Tuples group multiple values of different types
• Access using .0, .1, or destructure via pattern matching
• Ideal for returning multiple values from functions
• Fixed length and index order must be managed carefully

Next: Explore Rust – HashMap to store dynamic key-value pairs efficiently.

FAQs

Can a tuple contain different data types?
Yes. Unlike arrays, tuples can store heterogeneous types like (i32, f64, String).

Can I iterate over a tuple in Rust?
No. Tuples don’t implement Iterator because each element may have a different type. You must access elements manually or destructure them.

How do I return multiple values from a function?
Use tuples:

fn stats() -> (i32, i32) {
    (10, 20)
}

Can I name tuple elements like struct fields?
No. Tuples use index-based access. If you need named fields, use a struct.