Accessing a character in a borrowed string by index

Question

How would you access an element in a borrowed string by index?

Straightforward in Python:

my_string_lst = list(my_string) 
print my_string_list[0]
print my_string[0]                # same as above

Rust (attempt 1):

let my_string_vec = vec![my_string];    # doesn't work
println!("{}", my_string_vec[0]);       # returns entire of `my_string` 

Rust (attempt 2):

let my_string_vec = my_string.as_bytes();  # returns a &[u8]
println!("{}", my_string_vec[0]);          # prints nothing

My end goal is to stick it into a loop like this:

for pos in 0..my_string_vec.len() {
    while shift <= pos && my_string_vec[pos] != my_string_vec[pos-shift] {
        shift += shifts[pos-shift];
    }
    shifts[pos+1] = shift;
}

for ch in my_string_vec {
    let pos = 0;    // simulate some runtime index
    if my_other_string_vec[pos] != ch {
        ...
    }
}

I think it's possible to do use my_string_vec.as_bytes()[pos]and my_string_vec.as_bytes()[pos-shift]in my condition statement, but I feel that this has a bad code smell.

Answer 1

You can use char_at(index) to access a specific character. If you want to iterate over the characters in a string, you can use the chars() method which yields an iterator over the characters in the string.

The reason it was specifically not made possible to use indexing syntax is, IIRC, because indexing syntax would give the impression that it was like accessing a character in your typical C-string-like string, where accessing a character at a given index is a constant time operation (i.e. just accessing a single byte in an array). Strings in Rust, on the other hand, are Unicode and a single character may not necessarily consist of just one byte, making a specific character access a linear time operation, so it was decided to make that performance difference explicit and clear.

As far as I know, there is no method available for swapping characters in a string (see this question). Note that this wouldn't have been possible anyways via an immutably borrowed string, since such a string isn't yours to modify. You would have to most likely use a String, or perhaps a &mut str if you're strictly swapping, but I'm not too familiar with Unicode's intricacies.

I recommend instead you build up a String the way you want it, that way you don't have to worry about the mutability of the borrowed string. You'd refer/look into the borrowed string, and write into the output/build-up string accordingly based on your logic.

So this:

for pos in 0..my_string_vec.len() {
    while shift <= pos && my_string_vec[pos] != my_string_vec[pos-shift] {
        shift += shifts[pos-shift];
    }
    shifts[pos+1] = shift;
}

Might become something like this (not tested; not clear what your logic is for):

for ch in my_string.chars()
    while shift <= pos && ch != my_string.char_at(pos - shift) {
        // assuming shifts is a vec; not clear in question
        shift += shifts[pos - shift];
    }

    shifts.push(shift);
}

Your last for loop:

for ch in my_string_vec {
    let pos = 0;    // simulate some runtime index
    if my_other_string_vec[pos] != ch {
        ...
    }
}

That kind of seems like you want to compare a given character in string A with the corresponding character (in the same position) of string B. For this I would recommend zipping the chars iterator of the first with the second, something like:

for (left, right) in my_string.chars().zip(my_other_string.chars()) {
  if left != right {
  }
}

Note that zip() stops iterating as soon as either iterator stops, meaning that if the strings are not the same length, then it'll only go as far as the shortest string.

If you need access to the "character index" information, you could add .enumerate() to that, so the above would change to:

for (index, (left, right)) in my_string.chars().zip(my_other_string.chars()).enumerate()