Chapter 13 - Utility Traits

A helpful resource for better understanding the Cow enum is The Secret Life of Cows. Be sure to click on the “playground” links in the discussion there on the serde crate.

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

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

Part A

We can implement methods directly on shared reference types themselves. There is no deref coercion then when called on a shared reference that is of that shared reference type (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();    
}

Note how the implementation is for the ref string slice type, not the primitive string slice type.

Part B

1. Consider two traits

   1. From<String>

   2. From<&str>

2. The enum Cow<str> implements both traits

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

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

3. Consider another trait

   1. Into<Cow<str>>

4. A From implementation implies that there is a corresponding Into implementation. There is a blanket implementation of Into in the standard library. My guess is that the following code is the blanket implementation

   impl<T,U> Into<U> for T
      where U: From<T> {
      
     fn into(self) -> U {
       U::from(self)
     }  
   }

5. Therefore String implements the Into<Cow<str>> trait

   impl<'a> Into<Cow<'a, str>> for String {
     fn into(self) -> Cow<'a, str> {
       ...
     }
   }

6. Also &str implements the Into<Cow<str>> trait

   impl<'a> Into<Cow<'a, str>> for &'a str {
     fn into(self) -> Cow<'a, str> {
       ...
     }
   }

7. 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>

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

9. A string literal has a static lifetime.

10. Therefore the result of calling the into() method on a string literal is a Cow<'static, str>

11. Also we can call the into() method on a String to get a Cow<'static, str> without any lifetime limitations on the String