How can I concatenate two slices or two vectors and still have access to the original values?

Question

I have two slice or vectors and I want to add them, as demonstrated here in Golang:

a := []byte{1, 2, 3}
b := []byte{4, 5, 6}
ab := append(a, b...)
ba := append(b, a...)

How can I do that in Rust? I found some other questions, such as:

but, all of their best answer is a += b, and not ab = a + b.

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

a.append(&mut b);

assert_eq!(a, [1, 2, 3, 4, 5, 6]);
assert_eq!(b, []);

Or is there maybe a function like Vec::append(a, b) in Rust?

Can you please explain what your desired output is? What is wrong with the example code you were giving? What do you want to look `a` and `b` in the end? Do you want a new vector without modifying the others? — hellow, Jan 11 '19 at 08:06
Please answer **all** of my questions, because it is important on how to solve this problem. — hellow, Jan 11 '19 at 08:14
Do you want a new vector without modifying the others? I think should Yes. — wllenyj, Jan 11 '19 at 08:15

Boiethios · Answer 1 · 2019-01-11T11:08:17.420

You can chain your iterators:

fn main() {
    let a = vec![1, 2, 3];
    let b = vec![4, 5, 6];

    // Don't consume the original vectors and clone the items:
    let ab: Vec<_> = a.iter().chain(&b).cloned().collect();

    // Consume the original vectors. The items do not need to be cloneable:
    let ba: Vec<_> = b.into_iter().chain(a).collect();

    assert_eq!(ab, [1, 2, 3, 4, 5, 6]);
    assert_eq!(ba, [4, 5, 6, 1, 2, 3]);
}

Note that the iterator knows the number of items that it yields, so that collect can allocate directly the right amount of memory:

fn main() {
    let a = vec![1, 2, 3];
    let b = vec![4, 5, 6];

    let ba = b.into_iter().chain(a);
    assert_eq!(ba.size_hint(), (6, Some(6)));

    let ba: Vec<_> = ba.collect();
    assert_eq!(ba, [4, 5, 6, 1, 2, 3]);
}

score 6 · Answer 2 · answered Jan 11 '19 at 08:16

There is no constructor of Vec directly appending two slices.

The functionality is not fundamental, as you can implement it yourself:

let ab = {
    let mut r = a.clone();
    r.extend_from_slice(&b);
    r
};

If you often find yourself performing this operation, you may prefer to write a function to do so:

fn cat<T: Clone>(a: &[T], b: &[T]) -> Vec<T> {
    let mut v = Vec::with_capacity(a.len() + b.len());
    v.extend_from_slice(a);
    v.extend_from_slice(b);
    v
}

And then you'll be able to do: let ab = cat(&a, &b);.

How can I concatenate two slices or two vectors and still have access to the original values?

2 Answers2

Linked