What does “`str` does not have a constant size known at compile-time” mean, and what’s the simplest way to fix it?

by

TL;DR Don’t use str, use &str. The reference is important.

The issue can be simplified to this:

fn main() {
    let demo = "demo"[..];
}

You are attempting to slice a &str (but the same would happen for a String, &[T], Vec<T>, etc.), but have not taken a reference to the result. This means that the type of demo would be str. To fix it, add an &:

let demo = &"demo"[..];

In your broader example, you are also running into the fact that you are creating an allocated String inside of the match statement (via join) and then attempting to return a reference to it. This is disallowed because the String will be dropped at the end of the match, invalidating any references. In another language, this could lead to memory unsafety.

One potential fix is to store the created String for the duration of the function, preventing its deallocation until after the new string is created:

fn choose(s: &str, pad: u8) -> String {
    let tmp;

    match pad {
        0 => {
            tmp = ["000000000000000", s].join("");
            &tmp[s.len()..]
        }
        1 => {
            tmp = [s, "000000000000000"].join("");
            &tmp[..16]
        }
        _ => {
            tmp = ["00", s, "0000000000000"].join("");
            &tmp[..16]
        }
    }.to_string()
}

Editorially, there’s probably more efficient ways of writing this function. The formatting machinery has options for padding strings. You might even be able to just truncate the string returned from join without creating a new one.

What it means is harder to explain succinctly. Rust has a number of types that are unsized. The most prevalent ones are str and [T]. Contrast these types to how you normally see them used: &str or &[T]. You might even see them as Box<str> or Arc<[T]>. The commonality is that they are always used behind a reference of some kind.

Because these types don’t have a size, they cannot be stored in a variable on the stack — the compiler wouldn’t know how much stack space to reserve for them! That’s the essence of the error message.

See also:

More Related Contents:

  1. I want to run a loop in println [duplicate]
  2. Why is it discouraged to accept a reference to a String (&String), Vec (&Vec), or Box (&Box) as a function argument?
  3. Why does my string not match when reading user input from stdin?
  4. What are the differences between Rust’s `String` and `str`?
  5. How to match a String against string literals?
  6. How do I concatenate strings?
  7. How do I convert a Vec to Vec?
  8. Why is capitalizing the first letter of a string so convoluted in Rust?
  9. Convert Vec into a slice of &str in Rust?
  10. How does the lifetime work on constant strings / string literals?
  11. How do I convert between String, &str, Vec and &[u8]?
  12. How do I make format! return a &str from a conditional expression?
  13. Is there an owned version of String::chars?
  14. How can I use a dynamic format string with the format! macro?
  15. How to create a formatted String out of a literal in Rust?
  16. What is the equivalent of the join operator over a vector of Strings?
  17. Convert slice of string to slice of pointer to string
  18. How to index a String in Rust
  19. Can I convert a string to enum without macros in Rust?
  20. What’s the difference of strings within single or double quotes in groovy?
  21. Difference between text and varchar (character varying)
  22. Find string between two substrings [duplicate]
  23. Reversing a string in C
  24. String compare in Perl with “eq” vs “==” [duplicate]
  25. How to generate all the permutations of a multiset?
  26. Insert a character at a specific location in a string
  27. Convert R vector to string vector of 1 element [duplicate]
  28. Is there a function to split a string in Oracle PL/SQL?
  29. Line continuation of strings in Fortran
  30. How to parse string to date in xslt 2.0

Leave a Comment