How do I convert a Vec to a Vec without copying the vector?

by

You cannot change the type of a value in place in safe Rust. There is no guarantee that the two types will have the same size, alignment, or semantics.

This applies to a single value (T -> U) as well as aggregate values (Vec<T> -> Vec<U>, HashMap<K1, V1> -> HashMap<K2, V2>). Note that aggregate values are really just a special case of “single” values.

Create a new vector

The most straight-forward solution:

let buffer2 = buffer.into_iter().map(Foo).collect();

In cases where the compiler can tell that you aren’t actually changing important things, this becomes effectively a no-op:

fn convert(b: Vec<u32>) -> Vec<Foo> {
    b.into_iter().map(Foo).collect()
}

x86_64 assembly output for Rust 1.54 with optimizations:

playground::convert:
    movq    %rdi, %rax
    movq    (%rsi), %rcx
    movups  8(%rsi), %xmm0
    movq    %rcx, (%rdi)
    movups  %xmm0, 8(%rdi)
    retq

Unfortunately, this lightweight transformation isn’t currently a guaranteed property, only an implementation detail.

Use generics

You could adjust do_something_using_foo to take in a generic type and have both Foo and u32 implement a trait:

use std::borrow::{Borrow, BorrowMut};

#[derive(Debug, Clone)]
struct Foo(u32);

impl Borrow<u32> for Foo {
    fn borrow(&self) -> &u32 {
        &self.0
    }
}

impl BorrowMut<u32> for Foo {
    fn borrow_mut(&mut self) -> &mut u32 {
        &mut self.0
    }
}

fn do_something_using_foo<T>(buffer: &mut [T])
where
    T: BorrowMut<u32>,
{
}

fn main() {
    let mut buffer_u32 = vec![0u32; 100];
    let mut buffer_foo = vec![Foo(0); 100];

    do_something_using_foo(&mut buffer_u32);
    do_something_using_foo(&mut buffer_foo);
}

Unsafe Rust

It’s technically possible — you can shoot yourself in the foot as much as you’d like.

You can use something like std::mem::transmute if you know what you are doing.

However, it’s undefined behavior to use transmute with Vec as the representation of Vec is not defined. Instead, see Sven Marnach’s answer.

See also:

More Related Contents:

  1. What are non-lexical lifetimes?
  2. What are Rust’s exact auto-dereferencing rules?
  3. Why is a trait not implemented for a type that clearly has it implemented?
  4. How can I include a module from another file from the same project?
  5. What does “Sized is not implemented” mean?
  6. How do I implement a trait I don’t own for a type I don’t own?
  7. Mutably borrow one struct field while borrowing another in a closure
  8. What makes something a “trait object”?
  9. How do I convert a Vector of bytes (u8) to a string?
  10. Is it possible to use `impl Trait` as a function’s return type in a trait definition?
  11. Cannot borrow as immutable because it is also borrowed as mutable in function arguments
  12. What is the relation between auto-dereferencing and deref coercion?
  13. How to call a method when a trait and struct use the same method name?
  14. What does “cannot move out of index of” mean?
  15. What is the syntax: `instance.method::()`?
  16. Why does passing a closure to function which accepts a function pointer not work?
  17. “expected type parameter, found struct”
  18. Adding an append method to a singly linked list
  19. Is it possible to declare the type of the variable in Rust for loops?
  20. Is there a way to combine multiple traits in order to define a new trait? [duplicate]
  21. How can I store a pattern in a variable in Rust?
  22. Why does a mutable borrow of a closure through DerefMut not work?
  23. How to switch between Rust toolchains?
  24. Why can Serde not derive Deserialize for a struct containing only a &Path?
  25. How to quiet a warning for a single statement in Rust?
  26. Is there an elegant solution to modifying a structure while iterating?
  27. How do I cope with lazy iterators?
  28. Can a struct containing a raw pointer implement Send and be FFI safe?
  29. Lazy sequence generation in Rust
  30. Is there a way to get the field names of a struct in a macro?

Leave a Comment