Slices and strings

What is a slice?

A slice is a reference to a continuous part of a collection, instead of the whole thing. It is made of two numbers: a pointer to the first item and a length. A slice does not own anything; it borrows.

let s = String::from("Hello Delhi");
let hello: &str = &s[0..5];
let delhi: &str = &s[6..];   // from 6 to the end

  s:     ptr ---> H e l l o _ D e l h i
                  ^         ^
  hello: ptr -----+ len 5   |
  delhi: ptr ---------------+ len 5

Range shortcuts: [..3] means from the start, [3..] means to the end, [..] means everything.

String versus &str

A string literal like "Mumbai" is a &str that points into the program's own binary file, so it lives for the whole run. Its full type is &'static str, which you will understand in the lifetimes lesson.

Prefer &str for parameters

fn first_word(s: &str) -> &str {
    match s.find(' ') {
        Some(i) => &s[..i],
        None => s,
    }
}

fn main() {
    let owned = String::from("Jai Hind");
    println!("{}", first_word(&owned));     // works with &String
    println!("{}", first_word("Vande Mataram")); // and with literals
}

UTF-8: why slicing counts bytes

Rust strings are always UTF-8, a way of storing any language's text where each character takes 1 to 4 bytes. English letters take 1 byte. Most Hindi (Devanagari) characters take 3 bytes. The rupee sign ₹ also takes 3 bytes.

let word = "नमस्ते";
println!("{}", word.len());             // 18 bytes
println!("{}", word.chars().count());   // 6 chars
// &word[0..1]  -> panics: byte index 1 is not a char boundary

Also note: what a reader sees as one letter can be several chars. "स्ते" in नमस्ते is made of several Unicode code points. For "visible letters" you need a crate such as unicode-segmentation; for most programs, working with whole words and chars is enough.

Array slices

fn average(marks: &[u32]) -> f64 {
    let total: u32 = marks.iter().sum();
    total as f64 / marks.len() as f64
}

fn main() {
    let marks = [70, 80, 90, 60];
    println!("{}", average(&marks));        // whole array: 75
    println!("{}", average(&marks[1..3]));  // 80 and 90: 85
    let v = vec![50, 100];
    println!("{}", average(&v));            // a Vec works too: 75
}

Common mistakes

• Writing fn f(s: &String) for parameters. Use &str: it accepts more kinds of input.
• Indexing a string with s[0]. Rust does not allow it, because a byte may not be a whole character. Use s.chars().next().
• Assuming len() is the number of letters. It is the number of bytes.
• Returning a &str slice of a local String from a function. Return the String instead.