Remove an Element by Value from a Rust Vec<T>

You will learn how to find an item in a Rust vector with iter().position() and remove it with Vec::remove(). You will also learn when retain() is better for removing every matching item, and when swap_remove() is useful if element order does not matter.

A Vec<T> stores elements in a specific order and addresses them by index: 0, 1, 2, and so on. Therefore, Vec::remove() removes an element by index rather than by value.

To remove a known value, perform two operations:

1. Search the vector for the first index containing that value.
2. Remove the element at that index.

Rust expresses the search with iter().position(...). The position method returns:

• Some(index) when it finds a matching item.
• None when no item matches.

Because an element might not exist, Rust requires you to handle both cases before calling remove().

if let Some(index) = values.iter().position(|value| value == &target) {
    values.remove(index);
}

Searching is O(n) because the vector may need to inspect every element. remove(index) is also O(n) in the general case because every element after the removed one shifts left to preserve order. Together, the total work is still O(n).

Think of a vector as a numbered row of books on a shelf.

• position() walks along the shelf until it finds the requested book number.
• remove(index) takes that book out.
• To avoid a gap, every book to its right slides one place left.

The search needs the book's value; removal needs its shelf position. That is why these are separate operations.

Use iter().position() to find the first matching element, then pass its index to remove().

let mut fruits = vec!["apple", "banana", "orange"];

if let Some(index) = fruits.iter().position(|fruit| *fruit == "banana") {
    let removed = fruits.remove(index);
    println!("Removed: {removed}");
}

assert_eq!(fruits, vec!["apple", "orange"]);

fruits.iter() yields references such as &&str in this example, so the closure dereferences fruit with *fruit before comparing it to "banana".

For many types, comparing against a reference is often more convenient:

let mut numbers = vec![10, 20, 30];
let target = 20;

if let Some(index) = numbers.iter().position(|number| number == &target) {
    numbers.remove(index);
}

assert_eq!(numbers, vec![10, 30]);

remove() returns the value it removed, which is useful when you need to log it, process it, or store it elsewhere.

Consider this code:

let mut scores = vec![12, 25, 18, 25];
let target = 25;

if let Some(index) = scores.iter().position(|score| score == &target) {
    let removed = scores.remove(index);
    println!("Removed {removed}");
}

Execution proceeds as follows:

1. scores starts as [12, 25, 18, 25].
2. iter() visits the elements without changing the vector.
3. position() checks 12; it is not equal to 25.
4. It checks the next value, 25, and returns Some(1).
5. The if let pattern matches Some(1), so its body runs.
6. scores.remove(1) removes the first 25.
7. The later elements shift left to keep their order.
8. scores is now [12, 18, 25].

Only the first matching value is removed. The final 25 remains.

Removing by value appears when a program has a small ordered collection and receives an item to delete.

• To-do app: remove the first task matching a selected task ID.
• Game inventory: remove one matching potion after it is used.
• Configuration lists: remove a disabled feature name from a list.
• Command-line tools: remove a user-provided filename from an argument list.
• In-memory caches: remove a record from a small vector after matching a key.

When items have a unique identifier, search by that identifier instead of comparing every field of a larger struct.

In production code, the choice depends on whether you want to remove one item, all matching items, or prioritize speed over order.

Remove the first matching item

This is the usual position() plus remove() pattern:

fn remove_user(users: &mut Vec<String>, name: &str) -> Option<String> {
    let index = users.iter().position(|user| user == name)?;
    Some(users.remove(index))
}

The ? returns None early when no matching user exists. This makes the function concise while still handling the missing-item case safely.

Remove all matching items

Use retain() when duplicates should all be removed:

let mut tags = vec!["rust", "draft", "rust", "release"];
tags.retain(|tag| *tag != "rust");

assert_eq!(tags, vec!["draft", "release"]);

retain() examines the vector once and keeps only values for which the closure returns true.

Remove quickly when order is irrelevant

Use swap_remove() when changing order is acceptable:

let mut jobs = vec!["first", "second", "third"];
let removed = jobs.swap_remove(0);

assert_eq!(removed, "first");
assert_eq!(jobs, vec!["third", "second"]);

swap_remove() moves the final element into the removed slot rather than shifting all later elements. After finding the index, removal is O(1), but ordering changes.

Calling remove() with a value

This does not compile because remove() expects an index:

let mut values = vec![10, 20, 30];
values.remove(20); // Incorrect: 20 is treated as an index

Find the index first:

if let Some(index) = values.iter().position(|value| *value == 20) {
    values.remove(index);
}

Assuming the value always exists

position() returns an Option<usize>. Do not force it with unwrap() unless absence is truly a programming error.

let index = values.iter().position(|value| *value == 99).unwrap(); // May panic

Prefer if let, match, or returning Option from your function.

Expecting all duplicates to disappear

position() finds only the first match.

let mut values = vec![1, 2, 2, 3];
if let Some(index) = values.iter().position(|value| *value == 2) {
    values.remove(index);
}
assert_eq!(values, vec![1, 2, 3]);

Use retain() if you need to remove every 2.

Mutating while an iterator is still in use

Rust prevents unsafe simultaneous borrowing. Keep the search and mutation as separate completed operations, as in the position() then remove() examples.

Using swap_remove() while expecting stable order

swap_remove() is fast, but it can replace the removed item with the last element. Use remove() when order is part of your program's behavior.

Vec is a good fit when you need ordered iteration and a relatively small collection. If you frequently look up and remove values by key, a HashMap or HashSet may better match the problem.

// Remove the first matching value, preserving order.
if let Some(index) = values.iter().position(|item| item == &target) {
    let removed = values.remove(index);
}

// Return the removed item, or None when absent.
let removed = values
    .iter()
    .position(|item| item == &target)
    .map(|index| values.remove(index));

// Remove every matching value.
values.retain(|item| item != &target);

// Remove quickly when order does not matter.
if let Some(index) = values.iter().position(|item| item == &target) {
    values.swap_remove(index);
}

• position() returns Option<usize>.
• remove() preserves order and returns the removed item.
• position() removes only the first match when combined with remove().
• retain() removes all matches in one pass.
• swap_remove() changes order.
• Comparing values generally requires T: PartialEq.

Is there a Rust Vec::remove method that accepts a value?

No. Vec::remove() accepts an index because vectors are index-based collections. Use iter().position() to find a value's index first.

What does position() return in Rust?

It returns Some(index) for the first item matching the closure, or None if it finds no match.

Does position() and remove() run in O(n) time?

Yes. Searching is O(n), and ordered removal can shift later elements, which is also O(n). The combined operation is O(n).

How do I remove all matching values from a vector?

Use retain(). Return true for values you want to keep.

values.retain(|value| *value != 5);

How can I remove an item without preserving vector order?

Find its index and call swap_remove(index). This is O(1) for the removal itself, but the search still takes O(n).

Why does Rust make me handle None?

The requested value may not be in the vector. Handling None avoids using an invalid index or causing an unexpected panic.

Can I use this with custom structs?

Yes, as long as the compared fields support comparison. Usually you search by a field such as id, rather than requiring the entire struct to be equal.

• Option<T> — position() uses Option to represent a found or missing index.
• Iterators — iter(), position(), and closures provide expressive collection searches.
• Vec::retain — removes multiple matching values while preserving order.
• Vec::swap_remove — supports faster removal when element ordering is unimportant.
• Ownership and borrowing — explains why searches use references and why mutation must be safely sequenced.
• PartialEq — the trait that enables equality comparisons such as item == &target.
• HashMap and HashSet — alternatives for frequent lookup or removal by key.