Vectors

“See that vec of vecs over there?”
“Yeah. Can’t stand it.”
“Why?”
“It’s full of itself.”

A [u8; 4] has room for exactly four bytes; that's it.

When the number of items can vary, use a Vec<T> instead. It stores a sequence of values that can grow or shrink, without asking you to predict the final length.

Arrays First: Where Vectors Come From

To see why a Vec can grow, compare it with an array. An array [T; N] is a fixed-size, contiguous chunk of values whose length is part of the type:

let bytes: [u8; 4] = [10, 20, 30, 40];   // exactly four u8s, forever

Because this array is a local variable with a compile-time length, its elements can live directly on the stack alongside the function's other local data. Setting aside that stack space is cheap, and Rust reclaims it automatically when the function returns. The catch is that you can't grow it. bytes.push(50) doesn't compile because arrays have no push method: [u8; 4] holds exactly four elements, wherever it is stored.

Vec<T> solves that by storing the elements on the heap instead. The local Vec value is a small header containing a pointer, a length, and a capacity, while the allocator provides the buffer it points to. When you push and the buffer fills up, Vec requests more space and may move the elements to a new allocation. The header stays the same size; the buffer behind it grows.

A quick mental model:

If you're coming from Python or Java, Vec<T> is the closer match for the lists you use every day. In C, the same choice is closer to picking a fixed-size array or managing an allocation yourself. Rust gives you both choices, and its ownership rules apply to either one.

Vectors: Growable, Heap-Allocated

The <T> is a generic parameter: it works with any type, but a single Vec only holds one type at a time. So Vec<i32> is a vector of 32-bit integers, Vec<String> is a vector of owned strings.

You can start with an empty vector or with its initial items:

let mut empty: Vec<i32> = Vec::new();
let with_items = vec![1, 2, 3]; // vec! starts with these three items

Changing a vector requires mutable access, while reading it only needs a shared borrow:

let mut list = vec!["bread"];
list.push("milk");          // requires `mut`
let count = list.len();     // borrow without mut

When you choose a parameter type, start from what the function needs to do:

• Take a slice (&[T]) as input when the function only needs to read the data. This follows the same rule as &str in function parameters. A &[i32] parameter accepts a borrow of a Vec (&my_vec coerces to &[i32]), a borrow of an array (&[1, 2, 3]), or a sub-slice of either, without an explicit conversion. A parameter typed &Vec<i32> would only accept the first one and would offer nothing in return.
• Take &mut Vec<T> when you need to add or remove items.
• Take Vec<T> (no reference) when you actually want to consume the vector and take ownership.

Index access (list[0]) panics if out of bounds. list.get(0) returns Option<&T> instead, so you can handle a missing element without panicking.

Adding Items

Here you change the list in place by pushing a new item onto the end. The &mut Vec<String> says "I need exclusive access for a moment," and that exclusive borrow is what lets you push.

Useful from the Standard Library

• Vec::push appends one item to the end of the vector. It takes &mut self, which is why the parameter here is &mut Vec<String>.
• str::to_string (or String::from) turns the borrowed &str parameter into the owned String the vector wants to hold.

Searching the List

You only need to read the list here, comparing each element against the item you're looking for. The Vec holds Strings, but we're searching with a &str.

The parameter is &[String], a shared slice, because searching doesn't need to grow the list. It accepts borrowed vectors and arrays without copying their elements; the tests call it with both. An &Vec<String> parameter would unnecessarily rule out the array caller.

Useful from the Standard Library

• <[T]>::contains takes a reference to the element type: its signature is fn contains(&self, x: &T) -> bool. Here that's &String, while the parameter is &str. A loop lets you compare the strings without allocating a temporary String.
• A for entry in list loop yields &String on each iteration. Compare entry == item directly; no temporary String or .as_str() call is needed.

Building a List from Borrowed Slices

This time the input and output hold different string types: each input is a borrowed &str, while the output must own its Strings. That means every item needs to become an owned String before it can live in the result.

Useful from the Standard Library

• Vec::new creates an empty vector.
• Vec::push appends one item.
• str::to_string copies the text into an owned String, as in add_item.

Wrapping Up Vectors

You read a vector through a shared borrow and changed one through a mutable borrow. You also built a fresh Vec<String> from borrowed &str inputs.

What We Learned

• Vec<T> is a growable, heap-allocated array. The <T> is generic, but a single Vec only holds one type at a time.
• Build them with Vec::new() for an empty one, or the vec![...] macro when you already have the contents.
• Choose the parameter from the operation: &[T] to read, &mut Vec<T> to add or remove, and plain Vec<T> to consume the whole vector.
• push appends, pop removes the last item and returns Option<T>, len returns the number of items, and is_empty tells you whether there are any.
• Index access (list[i]) panics on out-of-bounds; list.get(i) returns Option<&T> and is the safer default.
• A for item in &list loop yields &T. That's usually what you want; iterating &mut list gives &mut T, and iterating list by value moves the items out.
• A Vec<String> is not the same as a Vec<&str>. Converting between them needs .to_string() / String::from (one direction) or .as_str() (the other).