Argthtjtr

I'm a beginner to Rust and just learning the ownership concept.

I'm using this function to reverse a String

fn reverse(input: &str) -> String {

    //we are receiving a borrowed value, 

    input

    //get an iterator of chars from the string slice

    .chars()

    //Goes between two iterators. 

    //From the doc:  double-ended iterator with the direction inverted.

    .rev()

    //collect into a String

    .collect::<String>()

}



fn process_reverse_case(input: &str, expected: &str) {

    assert_eq!(&reverse(input), expected)

}



fn main() {

    process_reverse_case("robot", "tobor");

}

I would like to understand who owns robot and tobor.

• I'm passing a borrowed value. Which is a string slice.


• I understand this can't be modified. So when we are collecting the reversed string, I think we are collecting it into a argument 1 of assert_eq!. Am I right?


• But as the process of reversing + collection happens inside reverse, the memory needed keeps increasing. Does argument 1 of assert_eq! account for that?


• The above question might have been solved by the compiler at compile time. Am I right?

Your claims are mostly wrong, let me try to correct them.

Passing a string slice, returning a string slice

fn reverse(input: &str) -> String you are accepting a string slice, but returning a String. A String "has ownership over the contents of the string".

I understand this [a string slice] can't be modified

You can modify a &mut str, e.g.

fn to_lower(s: &mut str) {

    s.make_ascii_lowercase();

}



fn main() {

    let mut a = String::from("ABC");

    println!("{}", a);

    to_lower(&mut a);

    println!("{}", a);

}

(playground)

So when we are collecting the reversed string, I think we are collecting it into a argument 1 of assert_eq!

No. You collect it into a string, that is what collect::<String>() is for. Also your function reverse returns a String.

This means, that you are calling the function reverse, which returns a String and you are passing that String as the first "argument" to the assert_eq! macro.

the memory needed keeps increasing. Does argument 1 of assert_eq! account for that?

No, how should it? That's all done inside of the reverse function. assert_eq! just takes two parameters. Where they come from is uncertain and not needed to know.

assert_eq!(&reverse(input), expected)

What happens in this line is, that you are calling your reverse function with input as parameter. But normally you can't compare &T with T (a reference to something with an actual instance of something), that's where the & (ampersand) in front of reverse comes into play. String implements the Deref trait which means it can be seen as a str as well (see the doc for Deref). But now you are trying to compare a str with &str, which does not work and that's why you put & in front, so you actually end up with &str and &str which you can compare with ==.

I would like to understand who ownes robot and tobor.

Nobody. In fact they live inside of the data section in the ELF/Binary itself. They don't have an owner per se, but can be used as &str wherever needed.