Page Comparison

...

Step-by-step, how to understand the describe() function example

(assuming I understand this, which is an if, a small if, but an if)

Part A - We can implement methods directly on shared references themselves. There is no dereferencing then (playground)

In a sense then the method implemented, when called on a shared reference, takes ownership of the shared reference, per se, not the value the shared reference points to.

use std::borrow::Cow;

trait CustomInto<T> {
    fn custom_into(self) -> T;
}

impl<'a> CustomInto<Cow<'a, str>> for &'a str {
    fn custom_into(self) -> Cow<'a, str> {
        Cow::Borrowed(self)
    }
}

fn main(){
    let _cow = "hello there".custom_into();    
}

Part B -

1. Consider two traits

   1. From<String>

   2. From<&'a str>

2. Cow<'a, str> implements both traits

   1. Cow has the associated function
      fn from(s: String) → Cow<'a, str>

   2. Cow has another associated function
      fn from(s: &'a str) → Cow<'a, str>

3. Therefore String implements<

1. Consider the additional trait

   1. Into<Into<Cow<'a, Cow<'a str>>

2. String automatically implements Into, as does str, given that the From traits are implemented

3. Both String and str implement Into with a method of the following form

   1. fn into(self) → Cow<a', str>

4. In the first four arms of the match expression, there are string literals upon which the method into() is called. We know the methods must have a return type of Cow<'static, str>.

5. A string literal is of type &str, a shared reference to a string slice.

6. When applying the method into(), the string literal is dereferenced into a string slice str

7. Then the method into() can be applied on the str. We have already seen that this method exists.