Understanding Rust Error E0620: Cast to an Unsized Type

Introduction to Rust Error E0620

Rust Error E0620 occurs when attempting to cast a value to an unsized type. Unsized types in Rust do not have a statically known size at compile-time, such as a slice type like [u32]. As Rust cannot compute the overall size, you can only manipulate such types through a reference or other pointer-type like Box or Rc.

Erroneous Code Example

#![allow(unused)]
fn main() {
    let x = &[1_usize, 2] as [usize]; // error: cast to unsized type: `&[usize; 2]` as `[usize]`
}

In the code snippet above, the error occurs because the developer tries to create an array (or more precisely, a slice) from a reference to an array of fixed size. The cast is not allowed because the target slice type does not have a statically known size.

Fixing Rust Error E0620

To fix Rust Error E0620, cast the value to a reference of the unsized type instead. Here's the corrected code example:

#![allow(unused)]
fn main() {
    let x = &[1_usize, 2] as &[usize]; // ok!
}

In this corrected example, the developer casts the value to a reference of the unsized type, &[usize], instead of using the unsized type directly. This change resolves the error as the overall size is not required for references.

Additional Examples and Explanations

In other cases of Rust Error E0620, the error may occur when trying to cast a sized type to an unsized type, such as a string slice. The fix remains the same: use a reference instead of the unsized type directly. Study this erroneous code and the corrected version:

// Erroneous code
#![allow(unused)]
fn main() {
    let s = String::from("hello");
    let t = s as str; // error: cast to unsized type: `String` as `str`
}

// Corrected code
#![allow(unused)]
fn main() {
    let s = String::from("hello");
    let t = &s as &str; // ok!
}

In the corrected code, using a reference to the unsized string slice (&str) instead of using the unsized type directly (str) resolves the error.