Is there a good way to convert a Vec to an array?

by

Arrays must be completely initialized, so you quickly run into concerns about what to do when you convert a vector with too many or too few elements into an array. These examples simply panic.

As of Rust 1.51 you can parameterize over an array’s length.

use std::convert::TryInto;

fn demo<T, const N: usize>(v: Vec<T>) -> [T; N] {
    v.try_into()
        .unwrap_or_else(|v: Vec<T>| panic!("Expected a Vec of length {} but it was {}", N, v.len()))
}

As of Rust 1.48, each size needs to be a specialized implementation:

use std::convert::TryInto;

fn demo<T>(v: Vec<T>) -> [T; 4] {
    v.try_into()
        .unwrap_or_else(|v: Vec<T>| panic!("Expected a Vec of length {} but it was {}", 4, v.len()))
}

As of Rust 1.43:

use std::convert::TryInto;

fn demo<T>(v: Vec<T>) -> [T; 4] {
    let boxed_slice = v.into_boxed_slice();
    let boxed_array: Box<[T; 4]> = match boxed_slice.try_into() {
        Ok(ba) => ba,
        Err(o) => panic!("Expected a Vec of length {} but it was {}", 4, o.len()),
    };
    *boxed_array
}

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. How do I implement a trait I don’t own for a type I don’t own?
  6. What makes something a “trait object”?
  7. How do I convert a Vector of bytes (u8) to a string?
  8. Is it possible to use `impl Trait` as a function’s return type in a trait definition?
  9. Cannot borrow as immutable because it is also borrowed as mutable in function arguments
  10. What is the relation between auto-dereferencing and deref coercion?
  11. What is the return type of the indexing operation?
  12. How to do a binary search on a Vec of floats?
  13. Change enum variant while moving the field to the new variant
  14. I implemented a trait for another trait but cannot call methods from both traits
  15. When is it useful to define multiple lifetimes in a struct?
  16. Lifetime troubles sharing references between threads
  17. Moved variable still borrowing after calling `drop`?
  18. Can I destructure a tuple without binding the result to a new variable in a let/match/for statement?
  19. What is the difference between Copy and Clone?
  20. Is it possible to have stack allocated arrays with the size determined at runtime in Rust?
  21. Temporary value is freed at the end of this statement [duplicate]
  22. Sharing a struct with trait objects as properties across threads
  23. Efficiently insert or replace multiple elements in the middle or at the beginning of a Vec?
  24. Calling a generic async function with a (mutably) borrowed argument
  25. Do all primitive types implement the Copy trait?
  26. Mutable reference to container object within iterator loop
  27. How to idiomatically alias a crate in Rust 2018?
  28. Why do I get “does not live long enough” in a return value?
  29. Why does the compiler not complain that an iterator moved to a for loop is immutable?
  30. Why doesn’t the lifetime of a mutable borrow end when the function call is complete?

Leave a Comment