Working with Multiple Values: Tuples, Arrays, and Vectors

Working Code

Try running this code in the Rust Playground!

fn main() {
    // Tuple: can hold values of different types
    let person = ("Minsu", 25, true);
    println!("Name: {}", person.0);
    println!("Age: {}", person.1);

    // Array: same type, fixed size
    let colors = ["red", "green", "blue"];
    println!("First color: {}", colors[0]);

    // Vector: same type, can grow and shrink
    let mut fruits = vec!["apple", "banana", "grape"];
    fruits.push("strawberry");
    println!("Number of fruits: {}", fruits.len());

    for fruit in &fruits {
        println!("🍎 {fruit}");
    }
}

All three are ways to group multiple values together. Each one has a different use case!

Try It Yourself

1. Use push to add 2 more of your favorite fruits to fruits.
2. What happens if you try to access an index that doesn't exist, like colors[5]? Try running it and see.

"Why?" — The Difference Between the Three Collections

| | Tuple | Array | Vec | | ---------- | ------------------ | -------------- | ------------------ | | Types | Different types OK | Same type only | Same type only | | Size | Fixed | Fixed | Resizable | | Creation | (val1, val2) | [val1, val2] | vec![val1, val2] | | Access | .0, .1 | [index] | [index] | | Add/Remove | Not possible | Not possible | push(), pop() |

If you're not sure which one to use, think of it this way:

• Tuple: When you want to bundle different kinds of values, like a name and an age
• Array: When you have a fixed list that will never change (days of the week, color sets, etc.)
• Vector: For almost everything else! This is the one you'll use the most in practice

fn main() {
    let mut scores = vec![90, 85, 77, 92];

    // Add an element
    scores.push(88);

    // Remove the last element
    let last = scores.pop(); // Some(88)
    println!("Popped value: {last:?}");

    // Iterate with for
    for score in &scores {
        println!("Score: {score}");
    }

    println!("Total of {} scores", scores.len());
}

Notice how pop() returns Some(88) instead of just 88? That's something called the Option type, which we'll cover later. For now, just think of it as a way to express "there might or might not be a value."

Deep Dive

fn main() {
    let person = ("Minsu", 25, true);

    // Destructure to give each value a name
    let (name, age, is_student) = person;
    println!("{name} is {age} years old");

    if is_student {
        println!("They're a student!");
    }
}

fn main() {
    let numbers = [1, 2, 3];
    println!("{}", numbers[10]); // panic!
}

thread 'main' panicked at 'index out of bounds: the len is 3 but the index is 10'

fn print_scores(scores: Vec<i32>) {
    for s in scores {
        println!("{s}");
    }
}

fn main() {
    let scores = vec![90, 85, 77];
    print_scores(scores);
    println!("Total of {} scores", scores.len()); // Error!
}

error[E0382]: borrow of moved value: `scores`

fn print_scores(scores: Vec<i32>) {
    for s in scores {
        println!("{s}");
    }
}

fn main() {
    let scores = vec![90, 85, 77];
    print_scores(scores.clone()); // Pass a copy!
    println!("Total of {} scores", scores.len()); // OK!
}

fn main() {
    let mut colors = vec!["red", "blue"];
    colors.push("green");
    colors.push("yellow");
    colors.pop();
    println!("{}", colors.len());
}

let data = (100, "hello", true);