How to Concatenate Vectors in Rust

By the end of this page, you will understand how to concatenate vectors in Rust, when to use append, extend, or iterator-based approaches, and how Rust's ownership and borrowing rules affect each option.

In Rust, concatenating vectors means taking elements from one collection and adding them to another. This is very common when building lists of results, combining data from multiple sources, or preparing values for later processing.

The main thing that makes Rust slightly different from some other languages is ownership. When you combine vectors, Rust needs to know:

• Are you moving elements from one vector into another?
• Are you copying elements?
• Do you want to keep the original vector intact?

Because of that, Rust provides multiple good solutions, each useful in a different situation.

The main options

• a.append(&mut b)

  • Moves all elements from b into a
  • b becomes empty afterward
  • Usually the most efficient choice when you no longer need b

• a.extend(b)

  • Consumes b and moves its elements into a
  • b cannot be used afterward
  • Clean and idiomatic when ownership transfer is fine

• a.extend(&b) or

Think of a vector like a box holding items.

• append is like pouring all items from box B into box A. Box B ends up empty.
• extend(b) is like handing box B over so its items can be transferred into box A. You give up B.
• extend(&b) or cloning is like making copies of the items in box B and placing the copies into box A. Box B stays unchanged.

The important question is: Do you want to move the original items, or keep them and make copies?

That one decision usually tells you which method to choose.

Core syntax

1. Move all elements and empty the second vector

let mut a = vec![1, 2, 3];
let mut b = vec![4, 5, 6];

a.append(&mut b);

println!("a = {:?}", a); // [1, 2, 3, 4, 5, 6]
println!("b = {:?}", b); // []

Use this when:

• you no longer need b
• you want an efficient in-place operation

2. Consume the second vector with extend

let mut a = vec![1, 2, 3];
let b = vec![4, , ];

a.(b);

(, a); 

Consider this example:

let mut a = vec![1, 2, 3];
let mut b = vec![4, 5, 6];

a.append(&mut b);

Step-by-step

1. a is created as [1, 2, 3].
2. b is created as [4, 5, 6].
3. a.append(&mut b) is called.
4. Rust takes all elements from b and moves them into a.
5. After the call:
   • a becomes [1, 2, 3, 4, 5, 6]
   • b becomes []

Another example with

Concatenating vectors shows up often in Rust applications.

Combining API results

If you fetch paginated results from an API, each page may return a Vec<Item>. You often append each page into one final vector.

all_items.append(&mut page_items);

Collecting validation errors

A form validator may gather errors from several checks and combine them into one list.

errors.extend(name_errors);
errors.extend(email_errors);

Merging log entries

A program might collect log entries from different modules and merge them into one ordered list for output or storage.

Processing files in batches

If several worker functions each return Vec<PathBuf> or Vec<String>, you can combine them into one vector for later processing.

Building command-line output

A CLI tool may gather results from multiple filters and combine them before printing or exporting.

In real Rust codebases, developers usually choose between append, extend, and iterator chains based on ownership and performance.

Common patterns

In-place accumulation

A very common pattern is to create one result vector and keep extending it:

let mut results = Vec::new();

results.extend(source_one());
results.extend(source_two());

This is simple and readable.

Efficient draining of temporary vectors

If a helper function returns a temporary vector that is only needed once, append is useful:

let mut all = Vec::new();
let mut batch = load_batch();
all.append(&mut batch);

This avoids unnecessary cloning.

Preserving inputs

1. Pushing references instead of values

Broken code:

let mut a = vec![1, 2, 3];
let b = vec![4, 5, 6];

for val in &b {
    a.push(val);
}

Why it fails:

• val is &i32
• a.push(...) expects i32

Fix:

for val in &b {
    a.push(*val);
}

Or more idiomatically:

a.extend(&b);

2. Using append without making the second vector mutable

// Move all items from b into a; b becomes empty
let mut a = vec![1, 2];
let mut b = vec![3, 4];
a.append(&mut b);

// Move items from b into a; b is consumed
let mut a = vec![1, 2];
let b = vec![3, 4];
a.extend(b);

// Keep b and copy values (good for Copy types like i32)
let mut a = vec![1, 2];
let b = vec![3, 4];
a.extend(&b);

// Keep b and clone values (good for String and other Clone types)
let mut a = vec![String::()];
  = [::()];
a.(b.().());


  = [, ];
  = [, ];
 : <_> = a.().(b.()).();

Can you concatenate vectors in Rust?

Yes. Common idiomatic ways include append, extend, and iterator chaining with chain(...).collect().

What is the most idiomatic way to combine two vectors in Rust?

If you want to add all elements from one vector into another, extend or append is usually the most idiomatic choice. The best one depends on whether you want to keep the second vector.

What is the difference between append and extend in Rust?

append takes &mut Vec<T> and empties the source vector. extend accepts any iterable and is more general.

Does append copy elements in Rust?

No. It moves the elements from the second vector into the first.

How do I concatenate vectors without losing the second vector?

For Copy types, use a.extend(&b). For non-Copy types, use a.extend(b.iter().cloned()).

• Ownership — Vector concatenation in Rust depends heavily on whether values are moved, borrowed, or cloned.
• Borrowing — Methods like extend(&b) and append(&mut b) use borrowing rules in different ways.
• Cloning — Needed when you want to preserve non-Copy values such as String.
• Iterators — extend, iter, into_iter, and chain are all based on iterator concepts.
• Vec — Understanding Rust's main growable array type helps make concatenation methods easier to choose.
• Copy vs Clone — This explains why integers are easy to duplicate but strings often need explicit cloning.
• Method syntax in Rust — Concatenation is usually done through vector methods like append and extend.
• Collecting into collections — Useful when using chain(...).collect() to build a new vector.